CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId" {:headers {:authorization ""
                                                                                                                               :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

DELETE /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  method: 'DELETE',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("DELETE", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"

response <- VERB("DELETE", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")

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

request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method DELETE \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")! 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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId" {:headers {:authorization ""
                                                                                                                            :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")! 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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments" {:headers {:authorization ""
                                                                                                                                    :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments"]
                                                       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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/AEAssessments")! 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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments" {:headers {:authorization ""
                                                                                                             :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments")! 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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments" {:headers {:authorization ""
                                                                                                              :api-version ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:AEAssessment {:Age 0
                                                                                                                                 :AssessmentCode ""
                                                                                                                                 :AssessmentDate ""
                                                                                                                                 :AssessmentEvent ""
                                                                                                                                 :AssessmentOverride ""
                                                                                                                                 :AssessmentResult ""
                                                                                                                                 :IsMemberOfAlternativePensionScheme false
                                                                                                                                 :OptOutWindowEndDate ""
                                                                                                                                 :QualifyingEarnings ""
                                                                                                                                 :ReenrolmentDate ""
                                                                                                                                 :StatePensionAge 0
                                                                                                                                 :StatePensionDate ""
                                                                                                                                 :TaxPeriod 0
                                                                                                                                 :TaxYear 0}}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
    Content = new StringContent("{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"

	payload := strings.NewReader("{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}")

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")
	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/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments HTTP/1.1
Authorization: 
Api-Version: 
Content-Type: application/json
Host: example.com
Content-Length: 406

{
  "AEAssessment": {
    "Age": 0,
    "AssessmentCode": "",
    "AssessmentDate": "",
    "AssessmentEvent": "",
    "AssessmentOverride": "",
    "AssessmentResult": "",
    "IsMemberOfAlternativePensionScheme": false,
    "OptOutWindowEndDate": "",
    "QualifyingEarnings": "",
    "ReenrolmentDate": "",
    "StatePensionAge": 0,
    "StatePensionDate": "",
    "TaxPeriod": 0,
    "TaxYear": 0
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"))
    .header("authorization", "")
    .header("api-version", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments")
  .post(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments")
  .header("authorization", "")
  .header("api-version", "")
  .header("content-type", "application/json")
  .body("{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}")
  .asString();

const data = JSON.stringify({
  AEAssessment: {
    Age: 0,
    AssessmentCode: '',
    AssessmentDate: '',
    AssessmentEvent: '',
    AssessmentOverride: '',
    AssessmentResult: '',
    IsMemberOfAlternativePensionScheme: false,
    OptOutWindowEndDate: '',
    QualifyingEarnings: '',
    ReenrolmentDate: '',
    StatePensionAge: 0,
    StatePensionDate: '',
    TaxPeriod: 0,
    TaxYear: 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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    AEAssessment: {
      Age: 0,
      AssessmentCode: '',
      AssessmentDate: '',
      AssessmentEvent: '',
      AssessmentOverride: '',
      AssessmentResult: '',
      IsMemberOfAlternativePensionScheme: false,
      OptOutWindowEndDate: '',
      QualifyingEarnings: '',
      ReenrolmentDate: '',
      StatePensionAge: 0,
      StatePensionDate: '',
      TaxPeriod: 0,
      TaxYear: 0
    }
  }
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments';
const options = {
  method: 'POST',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"AEAssessment":{"Age":0,"AssessmentCode":"","AssessmentDate":"","AssessmentEvent":"","AssessmentOverride":"","AssessmentResult":"","IsMemberOfAlternativePensionScheme":false,"OptOutWindowEndDate":"","QualifyingEarnings":"","ReenrolmentDate":"","StatePensionAge":0,"StatePensionDate":"","TaxPeriod":0,"TaxYear":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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments',
  method: 'POST',
  headers: {
    authorization: '',
    'api-version': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AEAssessment": {\n    "Age": 0,\n    "AssessmentCode": "",\n    "AssessmentDate": "",\n    "AssessmentEvent": "",\n    "AssessmentOverride": "",\n    "AssessmentResult": "",\n    "IsMemberOfAlternativePensionScheme": false,\n    "OptOutWindowEndDate": "",\n    "QualifyingEarnings": "",\n    "ReenrolmentDate": "",\n    "StatePensionAge": 0,\n    "StatePensionDate": "",\n    "TaxPeriod": 0,\n    "TaxYear": 0\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments")
  .post(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .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/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments',
  headers: {
    authorization: '',
    'api-version': '',
    '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({
  AEAssessment: {
    Age: 0,
    AssessmentCode: '',
    AssessmentDate: '',
    AssessmentEvent: '',
    AssessmentOverride: '',
    AssessmentResult: '',
    IsMemberOfAlternativePensionScheme: false,
    OptOutWindowEndDate: '',
    QualifyingEarnings: '',
    ReenrolmentDate: '',
    StatePensionAge: 0,
    StatePensionDate: '',
    TaxPeriod: 0,
    TaxYear: 0
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: {
    AEAssessment: {
      Age: 0,
      AssessmentCode: '',
      AssessmentDate: '',
      AssessmentEvent: '',
      AssessmentOverride: '',
      AssessmentResult: '',
      IsMemberOfAlternativePensionScheme: false,
      OptOutWindowEndDate: '',
      QualifyingEarnings: '',
      ReenrolmentDate: '',
      StatePensionAge: 0,
      StatePensionDate: '',
      TaxPeriod: 0,
      TaxYear: 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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments');

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

req.type('json');
req.send({
  AEAssessment: {
    Age: 0,
    AssessmentCode: '',
    AssessmentDate: '',
    AssessmentEvent: '',
    AssessmentOverride: '',
    AssessmentResult: '',
    IsMemberOfAlternativePensionScheme: false,
    OptOutWindowEndDate: '',
    QualifyingEarnings: '',
    ReenrolmentDate: '',
    StatePensionAge: 0,
    StatePensionDate: '',
    TaxPeriod: 0,
    TaxYear: 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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    AEAssessment: {
      Age: 0,
      AssessmentCode: '',
      AssessmentDate: '',
      AssessmentEvent: '',
      AssessmentOverride: '',
      AssessmentResult: '',
      IsMemberOfAlternativePensionScheme: false,
      OptOutWindowEndDate: '',
      QualifyingEarnings: '',
      ReenrolmentDate: '',
      StatePensionAge: 0,
      StatePensionDate: '',
      TaxPeriod: 0,
      TaxYear: 0
    }
  }
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments';
const options = {
  method: 'POST',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"AEAssessment":{"Age":0,"AssessmentCode":"","AssessmentDate":"","AssessmentEvent":"","AssessmentOverride":"","AssessmentResult":"","IsMemberOfAlternativePensionScheme":false,"OptOutWindowEndDate":"","QualifyingEarnings":"","ReenrolmentDate":"","StatePensionAge":0,"StatePensionDate":"","TaxPeriod":0,"TaxYear":0}}'
};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AEAssessment": @{ @"Age": @0, @"AssessmentCode": @"", @"AssessmentDate": @"", @"AssessmentEvent": @"", @"AssessmentOverride": @"", @"AssessmentResult": @"", @"IsMemberOfAlternativePensionScheme": @NO, @"OptOutWindowEndDate": @"", @"QualifyingEarnings": @"", @"ReenrolmentDate": @"", @"StatePensionAge": @0, @"StatePensionDate": @"", @"TaxPeriod": @0, @"TaxYear": @0 } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}" in

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

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments",
  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([
    'AEAssessment' => [
        'Age' => 0,
        'AssessmentCode' => '',
        'AssessmentDate' => '',
        'AssessmentEvent' => '',
        'AssessmentOverride' => '',
        'AssessmentResult' => '',
        'IsMemberOfAlternativePensionScheme' => null,
        'OptOutWindowEndDate' => '',
        'QualifyingEarnings' => '',
        'ReenrolmentDate' => '',
        'StatePensionAge' => 0,
        'StatePensionDate' => '',
        'TaxPeriod' => 0,
        'TaxYear' => 0
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: ",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments', [
  'body' => '{
  "AEAssessment": {
    "Age": 0,
    "AssessmentCode": "",
    "AssessmentDate": "",
    "AssessmentEvent": "",
    "AssessmentOverride": "",
    "AssessmentResult": "",
    "IsMemberOfAlternativePensionScheme": false,
    "OptOutWindowEndDate": "",
    "QualifyingEarnings": "",
    "ReenrolmentDate": "",
    "StatePensionAge": 0,
    "StatePensionDate": "",
    "TaxPeriod": 0,
    "TaxYear": 0
  }
}',
  'headers' => [
    'api-version' => '',
    'authorization' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AEAssessment' => [
    'Age' => 0,
    'AssessmentCode' => '',
    'AssessmentDate' => '',
    'AssessmentEvent' => '',
    'AssessmentOverride' => '',
    'AssessmentResult' => '',
    'IsMemberOfAlternativePensionScheme' => null,
    'OptOutWindowEndDate' => '',
    'QualifyingEarnings' => '',
    'ReenrolmentDate' => '',
    'StatePensionAge' => 0,
    'StatePensionDate' => '',
    'TaxPeriod' => 0,
    'TaxYear' => 0
  ]
]));

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

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

append(json_encode([
  'AEAssessment' => [
    'Age' => 0,
    'AssessmentCode' => '',
    'AssessmentDate' => '',
    'AssessmentEvent' => '',
    'AssessmentOverride' => '',
    'AssessmentResult' => '',
    'IsMemberOfAlternativePensionScheme' => null,
    'OptOutWindowEndDate' => '',
    'QualifyingEarnings' => '',
    'ReenrolmentDate' => '',
    'StatePensionAge' => 0,
    'StatePensionDate' => '',
    'TaxPeriod' => 0,
    'TaxYear' => 0
  ]
]));
$request->setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AEAssessment": {
    "Age": 0,
    "AssessmentCode": "",
    "AssessmentDate": "",
    "AssessmentEvent": "",
    "AssessmentOverride": "",
    "AssessmentResult": "",
    "IsMemberOfAlternativePensionScheme": false,
    "OptOutWindowEndDate": "",
    "QualifyingEarnings": "",
    "ReenrolmentDate": "",
    "StatePensionAge": 0,
    "StatePensionDate": "",
    "TaxPeriod": 0,
    "TaxYear": 0
  }
}'

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AEAssessment": {
    "Age": 0,
    "AssessmentCode": "",
    "AssessmentDate": "",
    "AssessmentEvent": "",
    "AssessmentOverride": "",
    "AssessmentResult": "",
    "IsMemberOfAlternativePensionScheme": false,
    "OptOutWindowEndDate": "",
    "QualifyingEarnings": "",
    "ReenrolmentDate": "",
    "StatePensionAge": 0,
    "StatePensionDate": "",
    "TaxPeriod": 0,
    "TaxYear": 0
  }
}'

import http.client

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

payload = "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}"

headers = {
    'authorization': "",
    'api-version': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments", payload, headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"

payload = { "AEAssessment": {
        "Age": 0,
        "AssessmentCode": "",
        "AssessmentDate": "",
        "AssessmentEvent": "",
        "AssessmentOverride": "",
        "AssessmentResult": "",
        "IsMemberOfAlternativePensionScheme": False,
        "OptOutWindowEndDate": "",
        "QualifyingEarnings": "",
        "ReenrolmentDate": "",
        "StatePensionAge": 0,
        "StatePensionDate": "",
        "TaxPeriod": 0,
        "TaxYear": 0
    } }
headers = {
    "authorization": "",
    "api-version": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments"

payload <- "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('authorization' = '', 'api-version' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["api-version"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
  req.body = "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments";

    let payload = json!({"AEAssessment": json!({
            "Age": 0,
            "AssessmentCode": "",
            "AssessmentDate": "",
            "AssessmentEvent": "",
            "AssessmentOverride": "",
            "AssessmentResult": "",
            "IsMemberOfAlternativePensionScheme": false,
            "OptOutWindowEndDate": "",
            "QualifyingEarnings": "",
            "ReenrolmentDate": "",
            "StatePensionAge": 0,
            "StatePensionDate": "",
            "TaxPeriod": 0,
            "TaxYear": 0
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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 '{
  "AEAssessment": {
    "Age": 0,
    "AssessmentCode": "",
    "AssessmentDate": "",
    "AssessmentEvent": "",
    "AssessmentOverride": "",
    "AssessmentResult": "",
    "IsMemberOfAlternativePensionScheme": false,
    "OptOutWindowEndDate": "",
    "QualifyingEarnings": "",
    "ReenrolmentDate": "",
    "StatePensionAge": 0,
    "StatePensionDate": "",
    "TaxPeriod": 0,
    "TaxYear": 0
  }
}' |  \
  http POST {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments \
  api-version:'' \
  authorization:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AEAssessment": {\n    "Age": 0,\n    "AssessmentCode": "",\n    "AssessmentDate": "",\n    "AssessmentEvent": "",\n    "AssessmentOverride": "",\n    "AssessmentResult": "",\n    "IsMemberOfAlternativePensionScheme": false,\n    "OptOutWindowEndDate": "",\n    "QualifyingEarnings": "",\n    "ReenrolmentDate": "",\n    "StatePensionAge": 0,\n    "StatePensionDate": "",\n    "TaxPeriod": 0,\n    "TaxYear": 0\n  }\n}' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessments

import Foundation

let headers = [
  "authorization": "",
  "api-version": "",
  "content-type": "application/json"
]
let parameters = ["AEAssessment": [
    "Age": 0,
    "AssessmentCode": "",
    "AssessmentDate": "",
    "AssessmentEvent": "",
    "AssessmentOverride": "",
    "AssessmentResult": "",
    "IsMemberOfAlternativePensionScheme": false,
    "OptOutWindowEndDate": "",
    "QualifyingEarnings": "",
    "ReenrolmentDate": "",
    "StatePensionAge": 0,
    "StatePensionDate": "",
    "TaxPeriod": 0,
    "TaxYear": 0
  ]] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId" {:headers {:authorization ""
                                                                                                                            :api-version ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:AEAssessment {:Age 0
                                                                                                                                               :AssessmentCode ""
                                                                                                                                               :AssessmentDate ""
                                                                                                                                               :AssessmentEvent ""
                                                                                                                                               :AssessmentOverride ""
                                                                                                                                               :AssessmentResult ""
                                                                                                                                               :IsMemberOfAlternativePensionScheme false
                                                                                                                                               :OptOutWindowEndDate ""
                                                                                                                                               :QualifyingEarnings ""
                                                                                                                                               :ReenrolmentDate ""
                                                                                                                                               :StatePensionAge 0
                                                                                                                                               :StatePensionDate ""
                                                                                                                                               :TaxPeriod 0
                                                                                                                                               :TaxYear 0}}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
    Content = new StringContent("{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"

	payload := strings.NewReader("{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}")

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

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

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

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

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

}

PUT /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId HTTP/1.1
Authorization: 
Api-Version: 
Content-Type: application/json
Host: example.com
Content-Length: 406

{
  "AEAssessment": {
    "Age": 0,
    "AssessmentCode": "",
    "AssessmentDate": "",
    "AssessmentEvent": "",
    "AssessmentOverride": "",
    "AssessmentResult": "",
    "IsMemberOfAlternativePensionScheme": false,
    "OptOutWindowEndDate": "",
    "QualifyingEarnings": "",
    "ReenrolmentDate": "",
    "StatePensionAge": 0,
    "StatePensionDate": "",
    "TaxPeriod": 0,
    "TaxYear": 0
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"))
    .header("authorization", "")
    .header("api-version", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")
  .put(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")
  .header("authorization", "")
  .header("api-version", "")
  .header("content-type", "application/json")
  .body("{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}")
  .asString();

const data = JSON.stringify({
  AEAssessment: {
    Age: 0,
    AssessmentCode: '',
    AssessmentDate: '',
    AssessmentEvent: '',
    AssessmentOverride: '',
    AssessmentResult: '',
    IsMemberOfAlternativePensionScheme: false,
    OptOutWindowEndDate: '',
    QualifyingEarnings: '',
    ReenrolmentDate: '',
    StatePensionAge: 0,
    StatePensionDate: '',
    TaxPeriod: 0,
    TaxYear: 0
  }
});

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

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

xhr.open('PUT', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    AEAssessment: {
      Age: 0,
      AssessmentCode: '',
      AssessmentDate: '',
      AssessmentEvent: '',
      AssessmentOverride: '',
      AssessmentResult: '',
      IsMemberOfAlternativePensionScheme: false,
      OptOutWindowEndDate: '',
      QualifyingEarnings: '',
      ReenrolmentDate: '',
      StatePensionAge: 0,
      StatePensionDate: '',
      TaxPeriod: 0,
      TaxYear: 0
    }
  }
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId';
const options = {
  method: 'PUT',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"AEAssessment":{"Age":0,"AssessmentCode":"","AssessmentDate":"","AssessmentEvent":"","AssessmentOverride":"","AssessmentResult":"","IsMemberOfAlternativePensionScheme":false,"OptOutWindowEndDate":"","QualifyingEarnings":"","ReenrolmentDate":"","StatePensionAge":0,"StatePensionDate":"","TaxPeriod":0,"TaxYear":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}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  method: 'PUT',
  headers: {
    authorization: '',
    'api-version': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AEAssessment": {\n    "Age": 0,\n    "AssessmentCode": "",\n    "AssessmentDate": "",\n    "AssessmentEvent": "",\n    "AssessmentOverride": "",\n    "AssessmentResult": "",\n    "IsMemberOfAlternativePensionScheme": false,\n    "OptOutWindowEndDate": "",\n    "QualifyingEarnings": "",\n    "ReenrolmentDate": "",\n    "StatePensionAge": 0,\n    "StatePensionDate": "",\n    "TaxPeriod": 0,\n    "TaxYear": 0\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")
  .put(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  headers: {
    authorization: '',
    'api-version': '',
    '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({
  AEAssessment: {
    Age: 0,
    AssessmentCode: '',
    AssessmentDate: '',
    AssessmentEvent: '',
    AssessmentOverride: '',
    AssessmentResult: '',
    IsMemberOfAlternativePensionScheme: false,
    OptOutWindowEndDate: '',
    QualifyingEarnings: '',
    ReenrolmentDate: '',
    StatePensionAge: 0,
    StatePensionDate: '',
    TaxPeriod: 0,
    TaxYear: 0
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: {
    AEAssessment: {
      Age: 0,
      AssessmentCode: '',
      AssessmentDate: '',
      AssessmentEvent: '',
      AssessmentOverride: '',
      AssessmentResult: '',
      IsMemberOfAlternativePensionScheme: false,
      OptOutWindowEndDate: '',
      QualifyingEarnings: '',
      ReenrolmentDate: '',
      StatePensionAge: 0,
      StatePensionDate: '',
      TaxPeriod: 0,
      TaxYear: 0
    }
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId');

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

req.type('json');
req.send({
  AEAssessment: {
    Age: 0,
    AssessmentCode: '',
    AssessmentDate: '',
    AssessmentEvent: '',
    AssessmentOverride: '',
    AssessmentResult: '',
    IsMemberOfAlternativePensionScheme: false,
    OptOutWindowEndDate: '',
    QualifyingEarnings: '',
    ReenrolmentDate: '',
    StatePensionAge: 0,
    StatePensionDate: '',
    TaxPeriod: 0,
    TaxYear: 0
  }
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    AEAssessment: {
      Age: 0,
      AssessmentCode: '',
      AssessmentDate: '',
      AssessmentEvent: '',
      AssessmentOverride: '',
      AssessmentResult: '',
      IsMemberOfAlternativePensionScheme: false,
      OptOutWindowEndDate: '',
      QualifyingEarnings: '',
      ReenrolmentDate: '',
      StatePensionAge: 0,
      StatePensionDate: '',
      TaxPeriod: 0,
      TaxYear: 0
    }
  }
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId';
const options = {
  method: 'PUT',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"AEAssessment":{"Age":0,"AssessmentCode":"","AssessmentDate":"","AssessmentEvent":"","AssessmentOverride":"","AssessmentResult":"","IsMemberOfAlternativePensionScheme":false,"OptOutWindowEndDate":"","QualifyingEarnings":"","ReenrolmentDate":"","StatePensionAge":0,"StatePensionDate":"","TaxPeriod":0,"TaxYear":0}}'
};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AEAssessment": @{ @"Age": @0, @"AssessmentCode": @"", @"AssessmentDate": @"", @"AssessmentEvent": @"", @"AssessmentOverride": @"", @"AssessmentResult": @"", @"IsMemberOfAlternativePensionScheme": @NO, @"OptOutWindowEndDate": @"", @"QualifyingEarnings": @"", @"ReenrolmentDate": @"", @"StatePensionAge": @0, @"StatePensionDate": @"", @"TaxPeriod": @0, @"TaxYear": @0 } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}" in

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

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'AEAssessment' => [
        'Age' => 0,
        'AssessmentCode' => '',
        'AssessmentDate' => '',
        'AssessmentEvent' => '',
        'AssessmentOverride' => '',
        'AssessmentResult' => '',
        'IsMemberOfAlternativePensionScheme' => null,
        'OptOutWindowEndDate' => '',
        'QualifyingEarnings' => '',
        'ReenrolmentDate' => '',
        'StatePensionAge' => 0,
        'StatePensionDate' => '',
        'TaxPeriod' => 0,
        'TaxYear' => 0
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: ",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId', [
  'body' => '{
  "AEAssessment": {
    "Age": 0,
    "AssessmentCode": "",
    "AssessmentDate": "",
    "AssessmentEvent": "",
    "AssessmentOverride": "",
    "AssessmentResult": "",
    "IsMemberOfAlternativePensionScheme": false,
    "OptOutWindowEndDate": "",
    "QualifyingEarnings": "",
    "ReenrolmentDate": "",
    "StatePensionAge": 0,
    "StatePensionDate": "",
    "TaxPeriod": 0,
    "TaxYear": 0
  }
}',
  'headers' => [
    'api-version' => '',
    'authorization' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AEAssessment' => [
    'Age' => 0,
    'AssessmentCode' => '',
    'AssessmentDate' => '',
    'AssessmentEvent' => '',
    'AssessmentOverride' => '',
    'AssessmentResult' => '',
    'IsMemberOfAlternativePensionScheme' => null,
    'OptOutWindowEndDate' => '',
    'QualifyingEarnings' => '',
    'ReenrolmentDate' => '',
    'StatePensionAge' => 0,
    'StatePensionDate' => '',
    'TaxPeriod' => 0,
    'TaxYear' => 0
  ]
]));

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

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

append(json_encode([
  'AEAssessment' => [
    'Age' => 0,
    'AssessmentCode' => '',
    'AssessmentDate' => '',
    'AssessmentEvent' => '',
    'AssessmentOverride' => '',
    'AssessmentResult' => '',
    'IsMemberOfAlternativePensionScheme' => null,
    'OptOutWindowEndDate' => '',
    'QualifyingEarnings' => '',
    'ReenrolmentDate' => '',
    'StatePensionAge' => 0,
    'StatePensionDate' => '',
    'TaxPeriod' => 0,
    'TaxYear' => 0
  ]
]));
$request->setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "AEAssessment": {
    "Age": 0,
    "AssessmentCode": "",
    "AssessmentDate": "",
    "AssessmentEvent": "",
    "AssessmentOverride": "",
    "AssessmentResult": "",
    "IsMemberOfAlternativePensionScheme": false,
    "OptOutWindowEndDate": "",
    "QualifyingEarnings": "",
    "ReenrolmentDate": "",
    "StatePensionAge": 0,
    "StatePensionDate": "",
    "TaxPeriod": 0,
    "TaxYear": 0
  }
}'

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "AEAssessment": {
    "Age": 0,
    "AssessmentCode": "",
    "AssessmentDate": "",
    "AssessmentEvent": "",
    "AssessmentOverride": "",
    "AssessmentResult": "",
    "IsMemberOfAlternativePensionScheme": false,
    "OptOutWindowEndDate": "",
    "QualifyingEarnings": "",
    "ReenrolmentDate": "",
    "StatePensionAge": 0,
    "StatePensionDate": "",
    "TaxPeriod": 0,
    "TaxYear": 0
  }
}'

import http.client

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

payload = "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}"

headers = {
    'authorization': "",
    'api-version': "",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"

payload = { "AEAssessment": {
        "Age": 0,
        "AssessmentCode": "",
        "AssessmentDate": "",
        "AssessmentEvent": "",
        "AssessmentOverride": "",
        "AssessmentResult": "",
        "IsMemberOfAlternativePensionScheme": False,
        "OptOutWindowEndDate": "",
        "QualifyingEarnings": "",
        "ReenrolmentDate": "",
        "StatePensionAge": 0,
        "StatePensionDate": "",
        "TaxPeriod": 0,
        "TaxYear": 0
    } }
headers = {
    "authorization": "",
    "api-version": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId"

payload <- "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('authorization' = '', 'api-version' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")

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

request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["api-version"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
  req.body = "{\n  \"AEAssessment\": {\n    \"Age\": 0,\n    \"AssessmentCode\": \"\",\n    \"AssessmentDate\": \"\",\n    \"AssessmentEvent\": \"\",\n    \"AssessmentOverride\": \"\",\n    \"AssessmentResult\": \"\",\n    \"IsMemberOfAlternativePensionScheme\": false,\n    \"OptOutWindowEndDate\": \"\",\n    \"QualifyingEarnings\": \"\",\n    \"ReenrolmentDate\": \"\",\n    \"StatePensionAge\": 0,\n    \"StatePensionDate\": \"\",\n    \"TaxPeriod\": 0,\n    \"TaxYear\": 0\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId";

    let payload = json!({"AEAssessment": json!({
            "Age": 0,
            "AssessmentCode": "",
            "AssessmentDate": "",
            "AssessmentEvent": "",
            "AssessmentOverride": "",
            "AssessmentResult": "",
            "IsMemberOfAlternativePensionScheme": false,
            "OptOutWindowEndDate": "",
            "QualifyingEarnings": "",
            "ReenrolmentDate": "",
            "StatePensionAge": 0,
            "StatePensionDate": "",
            "TaxPeriod": 0,
            "TaxYear": 0
        })});

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

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

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

    dbg!(results);
}

echo '{
  "AEAssessment": {
    "Age": 0,
    "AssessmentCode": "",
    "AssessmentDate": "",
    "AssessmentEvent": "",
    "AssessmentOverride": "",
    "AssessmentResult": "",
    "IsMemberOfAlternativePensionScheme": false,
    "OptOutWindowEndDate": "",
    "QualifyingEarnings": "",
    "ReenrolmentDate": "",
    "StatePensionAge": 0,
    "StatePensionDate": "",
    "TaxPeriod": 0,
    "TaxYear": 0
  }
}' |  \
  http PUT {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId \
  api-version:'' \
  authorization:'' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AEAssessment": {\n    "Age": 0,\n    "AssessmentCode": "",\n    "AssessmentDate": "",\n    "AssessmentEvent": "",\n    "AssessmentOverride": "",\n    "AssessmentResult": "",\n    "IsMemberOfAlternativePensionScheme": false,\n    "OptOutWindowEndDate": "",\n    "QualifyingEarnings": "",\n    "ReenrolmentDate": "",\n    "StatePensionAge": 0,\n    "StatePensionDate": "",\n    "TaxPeriod": 0,\n    "TaxYear": 0\n  }\n}' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId

import Foundation

let headers = [
  "authorization": "",
  "api-version": "",
  "content-type": "application/json"
]
let parameters = ["AEAssessment": [
    "Age": 0,
    "AssessmentCode": "",
    "AssessmentDate": "",
    "AssessmentEvent": "",
    "AssessmentOverride": "",
    "AssessmentResult": "",
    "IsMemberOfAlternativePensionScheme": false,
    "OptOutWindowEndDate": "",
    "QualifyingEarnings": "",
    "ReenrolmentDate": "",
    "StatePensionAge": 0,
    "StatePensionDate": "",
    "TaxPeriod": 0,
    "TaxYear": 0
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/AEAssessment/:AEAssessmentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/Secrets" {:headers {:authorization ""
                                                              :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Secrets"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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

var client = new RestClient("{{baseUrl}}/Secrets");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

POST /baseUrl/Secrets HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/Secrets")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Secrets"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Secrets")
  .post(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/Secrets")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Secrets');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/Secrets',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Secrets';
const options = {method: 'POST', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Secrets',
  method: 'POST',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Secrets")
  .post(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Secrets',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Secrets',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Secrets',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Secrets';
const options = {method: 'POST', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Secrets"]
                                                       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}}/Secrets" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Secrets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/Secrets', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Secrets');
$request->setRequestMethod('POST');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Secrets' -Method POST -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Secrets' -Method POST -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("POST", "/baseUrl/Secrets", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Secrets"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

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

response <- VERB("POST", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.post('/baseUrl/Secrets') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Secrets \
  api-version:'' \
  authorization:''

wget --quiet \
  --method POST \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Secrets

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/Secret/:SecretId" {:headers {:authorization ""
                                                                      :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Secret/:SecretId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/Secret/:SecretId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Secret/:SecretId");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Secret/:SecretId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

PUT /baseUrl/Secret/:SecretId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/Secret/:SecretId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Secret/:SecretId"))
    .header("authorization", "")
    .header("api-version", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/Secret/:SecretId")
  .put(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/Secret/:SecretId")
  .header("authorization", "")
  .header("api-version", "")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/Secret/:SecretId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Secret/:SecretId';
const options = {method: 'PUT', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Secret/:SecretId',
  method: 'PUT',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Secret/:SecretId")
  .put(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Secret/:SecretId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/Secret/:SecretId');

req.headers({
  authorization: '',
  'api-version': ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Secret/:SecretId';
const options = {method: 'PUT', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Secret/:SecretId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/Secret/:SecretId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Secret/:SecretId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/Secret/:SecretId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Secret/:SecretId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Secret/:SecretId');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Secret/:SecretId' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Secret/:SecretId' -Method PUT -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("PUT", "/baseUrl/Secret/:SecretId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Secret/:SecretId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Secret/:SecretId"

response <- VERB("PUT", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Secret/:SecretId")

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

request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.put('/baseUrl/Secret/:SecretId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".parse().unwrap());

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

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

    dbg!(results);
}

http PUT {{baseUrl}}/Secret/:SecretId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method PUT \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Secret/:SecretId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Secret/:SecretId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Secret/:SecretId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/Secret/:SecretId" {:headers {:authorization ""
                                                                         :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Secret/:SecretId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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

var client = new RestClient("{{baseUrl}}/Secret/:SecretId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Secret/:SecretId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

DELETE /baseUrl/Secret/:SecretId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/Secret/:SecretId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Secret/:SecretId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Secret/:SecretId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/Secret/:SecretId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Secret/:SecretId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Secret/:SecretId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Secret/:SecretId',
  method: 'DELETE',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Secret/:SecretId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Secret/:SecretId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/Secret/:SecretId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Secret/:SecretId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Secret/:SecretId"]
                                                       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}}/Secret/:SecretId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Secret/:SecretId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/Secret/:SecretId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Secret/:SecretId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Secret/:SecretId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Secret/:SecretId' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("DELETE", "/baseUrl/Secret/:SecretId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Secret/:SecretId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Secret/:SecretId"

response <- VERB("DELETE", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Secret/:SecretId")

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

request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/Secret/:SecretId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Secret/:SecretId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method DELETE \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Secret/:SecretId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Secret/:SecretId" {:headers {:authorization ""
                                                                      :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Secret/:SecretId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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

var client = new RestClient("{{baseUrl}}/Secret/:SecretId");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Secret/:SecretId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Secret/:SecretId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Secret/:SecretId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Secret/:SecretId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Secret/:SecretId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Secret/:SecretId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Secret/:SecretId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Secret/:SecretId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Secret/:SecretId',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Secret/:SecretId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Secret/:SecretId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Secret/:SecretId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Secret/:SecretId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Secret/:SecretId"]
                                                       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}}/Secret/:SecretId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Secret/:SecretId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Secret/:SecretId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Secret/:SecretId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Secret/:SecretId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Secret/:SecretId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Secret/:SecretId' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Secret/:SecretId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Secret/:SecretId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Secret/:SecretId"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Secret/:SecretId")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Secret/:SecretId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Secret/:SecretId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Secret/:SecretId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Secrets" {:headers {:authorization ""
                                                             :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Secrets"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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

var client = new RestClient("{{baseUrl}}/Secrets");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Secrets HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Secrets"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Secrets")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Secrets")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Secrets');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Secrets',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Secrets';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Secrets',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Secrets")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Secrets',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Secrets',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Secrets',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Secrets';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Secrets"]
                                                       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}}/Secrets" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Secrets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Secrets', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Secrets');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Secrets' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Secrets' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

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

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

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

import requests

url = "{{baseUrl}}/Secrets"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Secrets') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Secrets \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Secrets

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Secrets")! 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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions" {:headers {:authorization ""
                                                                                                                          :api-version ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:CisInstruction {:CisLineTag ""
                                                                                                                                               :CisLineType ""
                                                                                                                                               :Description ""
                                                                                                                                               :PayFrequency ""
                                                                                                                                               :PeriodEnd 0
                                                                                                                                               :PeriodStart 0
                                                                                                                                               :TaxYearEnd 0
                                                                                                                                               :TaxYearStart 0
                                                                                                                                               :UOM ""
                                                                                                                                               :Units ""
                                                                                                                                               :VAT ""
                                                                                                                                               :Value ""}}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
    Content = new StringContent("{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"

	payload := strings.NewReader("{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}")

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")
	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/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions HTTP/1.1
Authorization: 
Api-Version: 
Content-Type: application/json
Host: example.com
Content-Length: 270

{
  "CisInstruction": {
    "CisLineTag": "",
    "CisLineType": "",
    "Description": "",
    "PayFrequency": "",
    "PeriodEnd": 0,
    "PeriodStart": 0,
    "TaxYearEnd": 0,
    "TaxYearStart": 0,
    "UOM": "",
    "Units": "",
    "VAT": "",
    "Value": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"))
    .header("authorization", "")
    .header("api-version", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions")
  .post(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions")
  .header("authorization", "")
  .header("api-version", "")
  .header("content-type", "application/json")
  .body("{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  CisInstruction: {
    CisLineTag: '',
    CisLineType: '',
    Description: '',
    PayFrequency: '',
    PeriodEnd: 0,
    PeriodStart: 0,
    TaxYearEnd: 0,
    TaxYearStart: 0,
    UOM: '',
    Units: '',
    VAT: '',
    Value: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    CisInstruction: {
      CisLineTag: '',
      CisLineType: '',
      Description: '',
      PayFrequency: '',
      PeriodEnd: 0,
      PeriodStart: 0,
      TaxYearEnd: 0,
      TaxYearStart: 0,
      UOM: '',
      Units: '',
      VAT: '',
      Value: ''
    }
  }
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions';
const options = {
  method: 'POST',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"CisInstruction":{"CisLineTag":"","CisLineType":"","Description":"","PayFrequency":"","PeriodEnd":0,"PeriodStart":0,"TaxYearEnd":0,"TaxYearStart":0,"UOM":"","Units":"","VAT":"","Value":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions',
  method: 'POST',
  headers: {
    authorization: '',
    'api-version': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CisInstruction": {\n    "CisLineTag": "",\n    "CisLineType": "",\n    "Description": "",\n    "PayFrequency": "",\n    "PeriodEnd": 0,\n    "PeriodStart": 0,\n    "TaxYearEnd": 0,\n    "TaxYearStart": 0,\n    "UOM": "",\n    "Units": "",\n    "VAT": "",\n    "Value": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions")
  .post(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .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/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions',
  headers: {
    authorization: '',
    'api-version': '',
    '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({
  CisInstruction: {
    CisLineTag: '',
    CisLineType: '',
    Description: '',
    PayFrequency: '',
    PeriodEnd: 0,
    PeriodStart: 0,
    TaxYearEnd: 0,
    TaxYearStart: 0,
    UOM: '',
    Units: '',
    VAT: '',
    Value: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: {
    CisInstruction: {
      CisLineTag: '',
      CisLineType: '',
      Description: '',
      PayFrequency: '',
      PeriodEnd: 0,
      PeriodStart: 0,
      TaxYearEnd: 0,
      TaxYearStart: 0,
      UOM: '',
      Units: '',
      VAT: '',
      Value: ''
    }
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions');

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

req.type('json');
req.send({
  CisInstruction: {
    CisLineTag: '',
    CisLineType: '',
    Description: '',
    PayFrequency: '',
    PeriodEnd: 0,
    PeriodStart: 0,
    TaxYearEnd: 0,
    TaxYearStart: 0,
    UOM: '',
    Units: '',
    VAT: '',
    Value: ''
  }
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    CisInstruction: {
      CisLineTag: '',
      CisLineType: '',
      Description: '',
      PayFrequency: '',
      PeriodEnd: 0,
      PeriodStart: 0,
      TaxYearEnd: 0,
      TaxYearStart: 0,
      UOM: '',
      Units: '',
      VAT: '',
      Value: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions';
const options = {
  method: 'POST',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"CisInstruction":{"CisLineTag":"","CisLineType":"","Description":"","PayFrequency":"","PeriodEnd":0,"PeriodStart":0,"TaxYearEnd":0,"TaxYearStart":0,"UOM":"","Units":"","VAT":"","Value":""}}'
};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"CisInstruction": @{ @"CisLineTag": @"", @"CisLineType": @"", @"Description": @"", @"PayFrequency": @"", @"PeriodEnd": @0, @"PeriodStart": @0, @"TaxYearEnd": @0, @"TaxYearStart": @0, @"UOM": @"", @"Units": @"", @"VAT": @"", @"Value": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"]
                                                       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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions",
  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([
    'CisInstruction' => [
        'CisLineTag' => '',
        'CisLineType' => '',
        'Description' => '',
        'PayFrequency' => '',
        'PeriodEnd' => 0,
        'PeriodStart' => 0,
        'TaxYearEnd' => 0,
        'TaxYearStart' => 0,
        'UOM' => '',
        'Units' => '',
        'VAT' => '',
        'Value' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: ",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions', [
  'body' => '{
  "CisInstruction": {
    "CisLineTag": "",
    "CisLineType": "",
    "Description": "",
    "PayFrequency": "",
    "PeriodEnd": 0,
    "PeriodStart": 0,
    "TaxYearEnd": 0,
    "TaxYearStart": 0,
    "UOM": "",
    "Units": "",
    "VAT": "",
    "Value": ""
  }
}',
  'headers' => [
    'api-version' => '',
    'authorization' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CisInstruction' => [
    'CisLineTag' => '',
    'CisLineType' => '',
    'Description' => '',
    'PayFrequency' => '',
    'PeriodEnd' => 0,
    'PeriodStart' => 0,
    'TaxYearEnd' => 0,
    'TaxYearStart' => 0,
    'UOM' => '',
    'Units' => '',
    'VAT' => '',
    'Value' => ''
  ]
]));

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

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

append(json_encode([
  'CisInstruction' => [
    'CisLineTag' => '',
    'CisLineType' => '',
    'Description' => '',
    'PayFrequency' => '',
    'PeriodEnd' => 0,
    'PeriodStart' => 0,
    'TaxYearEnd' => 0,
    'TaxYearStart' => 0,
    'UOM' => '',
    'Units' => '',
    'VAT' => '',
    'Value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CisInstruction": {
    "CisLineTag": "",
    "CisLineType": "",
    "Description": "",
    "PayFrequency": "",
    "PeriodEnd": 0,
    "PeriodStart": 0,
    "TaxYearEnd": 0,
    "TaxYearStart": 0,
    "UOM": "",
    "Units": "",
    "VAT": "",
    "Value": ""
  }
}'

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CisInstruction": {
    "CisLineTag": "",
    "CisLineType": "",
    "Description": "",
    "PayFrequency": "",
    "PeriodEnd": 0,
    "PeriodStart": 0,
    "TaxYearEnd": 0,
    "TaxYearStart": 0,
    "UOM": "",
    "Units": "",
    "VAT": "",
    "Value": ""
  }
}'

import http.client

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

payload = "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}"

headers = {
    'authorization': "",
    'api-version': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"

payload = { "CisInstruction": {
        "CisLineTag": "",
        "CisLineType": "",
        "Description": "",
        "PayFrequency": "",
        "PeriodEnd": 0,
        "PeriodStart": 0,
        "TaxYearEnd": 0,
        "TaxYearStart": 0,
        "UOM": "",
        "Units": "",
        "VAT": "",
        "Value": ""
    } }
headers = {
    "authorization": "",
    "api-version": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"

payload <- "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('authorization' = '', 'api-version' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["api-version"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
  req.body = "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions";

    let payload = json!({"CisInstruction": json!({
            "CisLineTag": "",
            "CisLineType": "",
            "Description": "",
            "PayFrequency": "",
            "PeriodEnd": 0,
            "PeriodStart": 0,
            "TaxYearEnd": 0,
            "TaxYearStart": 0,
            "UOM": "",
            "Units": "",
            "VAT": "",
            "Value": ""
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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 '{
  "CisInstruction": {
    "CisLineTag": "",
    "CisLineType": "",
    "Description": "",
    "PayFrequency": "",
    "PeriodEnd": 0,
    "PeriodStart": 0,
    "TaxYearEnd": 0,
    "TaxYearStart": 0,
    "UOM": "",
    "Units": "",
    "VAT": "",
    "Value": ""
  }
}' |  \
  http POST {{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions \
  api-version:'' \
  authorization:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CisInstruction": {\n    "CisLineTag": "",\n    "CisLineType": "",\n    "Description": "",\n    "PayFrequency": "",\n    "PeriodEnd": 0,\n    "PeriodStart": 0,\n    "TaxYearEnd": 0,\n    "TaxYearStart": 0,\n    "UOM": "",\n    "Units": "",\n    "VAT": "",\n    "Value": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions

import Foundation

let headers = [
  "authorization": "",
  "api-version": "",
  "content-type": "application/json"
]
let parameters = ["CisInstruction": [
    "CisLineTag": "",
    "CisLineType": "",
    "Description": "",
    "PayFrequency": "",
    "PeriodEnd": 0,
    "PeriodStart": 0,
    "TaxYearEnd": 0,
    "TaxYearStart": 0,
    "UOM": "",
    "Units": "",
    "VAT": "",
    "Value": ""
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions")! 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}}/Employer/:EmployerId/CisLineTypes");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/Employer/:EmployerId/CisLineTypes" {:headers {:authorization ""
                                                                                        :api-version ""}
                                                                              :content-type :json
                                                                              :form-params {:CisLineType {:Description ""
                                                                                                          :LineType ""
                                                                                                          :NominalCode {:@href ""
                                                                                                                        :@rel ""
                                                                                                                        :@title ""}
                                                                                                          :TaxTreatment ""}}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/CisLineTypes"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/Employer/:EmployerId/CisLineTypes"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
    Content = new StringContent("{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/CisLineTypes");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/CisLineTypes"

	payload := strings.NewReader("{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}")

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")
	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/Employer/:EmployerId/CisLineTypes HTTP/1.1
Authorization: 
Api-Version: 
Content-Type: application/json
Host: example.com
Content-Length: 176

{
  "CisLineType": {
    "Description": "",
    "LineType": "",
    "NominalCode": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "TaxTreatment": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/Employer/:EmployerId/CisLineTypes")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/CisLineTypes"))
    .header("authorization", "")
    .header("api-version", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/CisLineTypes")
  .post(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/Employer/:EmployerId/CisLineTypes")
  .header("authorization", "")
  .header("api-version", "")
  .header("content-type", "application/json")
  .body("{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  CisLineType: {
    Description: '',
    LineType: '',
    NominalCode: {
      '@href': '',
      '@rel': '',
      '@title': ''
    },
    TaxTreatment: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/Employer/:EmployerId/CisLineTypes');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineTypes',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    CisLineType: {
      Description: '',
      LineType: '',
      NominalCode: {'@href': '', '@rel': '', '@title': ''},
      TaxTreatment: ''
    }
  }
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisLineTypes';
const options = {
  method: 'POST',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"CisLineType":{"Description":"","LineType":"","NominalCode":{"@href":"","@rel":"","@title":""},"TaxTreatment":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineTypes',
  method: 'POST',
  headers: {
    authorization: '',
    'api-version': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CisLineType": {\n    "Description": "",\n    "LineType": "",\n    "NominalCode": {\n      "@href": "",\n      "@rel": "",\n      "@title": ""\n    },\n    "TaxTreatment": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/CisLineTypes")
  .post(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .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/Employer/:EmployerId/CisLineTypes',
  headers: {
    authorization: '',
    'api-version': '',
    '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({
  CisLineType: {
    Description: '',
    LineType: '',
    NominalCode: {'@href': '', '@rel': '', '@title': ''},
    TaxTreatment: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineTypes',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: {
    CisLineType: {
      Description: '',
      LineType: '',
      NominalCode: {'@href': '', '@rel': '', '@title': ''},
      TaxTreatment: ''
    }
  },
  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}}/Employer/:EmployerId/CisLineTypes');

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

req.type('json');
req.send({
  CisLineType: {
    Description: '',
    LineType: '',
    NominalCode: {
      '@href': '',
      '@rel': '',
      '@title': ''
    },
    TaxTreatment: ''
  }
});

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}}/Employer/:EmployerId/CisLineTypes',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    CisLineType: {
      Description: '',
      LineType: '',
      NominalCode: {'@href': '', '@rel': '', '@title': ''},
      TaxTreatment: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisLineTypes';
const options = {
  method: 'POST',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"CisLineType":{"Description":"","LineType":"","NominalCode":{"@href":"","@rel":"","@title":""},"TaxTreatment":""}}'
};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"CisLineType": @{ @"Description": @"", @"LineType": @"", @"NominalCode": @{ @"@href": @"", @"@rel": @"", @"@title": @"" }, @"TaxTreatment": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/CisLineTypes"]
                                                       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}}/Employer/:EmployerId/CisLineTypes" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/Employer/:EmployerId/CisLineTypes",
  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([
    'CisLineType' => [
        'Description' => '',
        'LineType' => '',
        'NominalCode' => [
                '@href' => '',
                '@rel' => '',
                '@title' => ''
        ],
        'TaxTreatment' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: ",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/Employer/:EmployerId/CisLineTypes', [
  'body' => '{
  "CisLineType": {
    "Description": "",
    "LineType": "",
    "NominalCode": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "TaxTreatment": ""
  }
}',
  'headers' => [
    'api-version' => '',
    'authorization' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/CisLineTypes');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CisLineType' => [
    'Description' => '',
    'LineType' => '',
    'NominalCode' => [
        '@href' => '',
        '@rel' => '',
        '@title' => ''
    ],
    'TaxTreatment' => ''
  ]
]));

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

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

append(json_encode([
  'CisLineType' => [
    'Description' => '',
    'LineType' => '',
    'NominalCode' => [
        '@href' => '',
        '@rel' => '',
        '@title' => ''
    ],
    'TaxTreatment' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/Employer/:EmployerId/CisLineTypes');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/CisLineTypes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CisLineType": {
    "Description": "",
    "LineType": "",
    "NominalCode": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "TaxTreatment": ""
  }
}'

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/CisLineTypes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CisLineType": {
    "Description": "",
    "LineType": "",
    "NominalCode": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "TaxTreatment": ""
  }
}'

import http.client

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

payload = "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}"

headers = {
    'authorization': "",
    'api-version': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/Employer/:EmployerId/CisLineTypes", payload, headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/CisLineTypes"

payload = { "CisLineType": {
        "Description": "",
        "LineType": "",
        "NominalCode": {
            "@href": "",
            "@rel": "",
            "@title": ""
        },
        "TaxTreatment": ""
    } }
headers = {
    "authorization": "",
    "api-version": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/CisLineTypes"

payload <- "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('authorization' = '', 'api-version' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/CisLineTypes")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["api-version"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/Employer/:EmployerId/CisLineTypes') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
  req.body = "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"CisLineType": json!({
            "Description": "",
            "LineType": "",
            "NominalCode": json!({
                "@href": "",
                "@rel": "",
                "@title": ""
            }),
            "TaxTreatment": ""
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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 '{
  "CisLineType": {
    "Description": "",
    "LineType": "",
    "NominalCode": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "TaxTreatment": ""
  }
}' |  \
  http POST {{baseUrl}}/Employer/:EmployerId/CisLineTypes \
  api-version:'' \
  authorization:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CisLineType": {\n    "Description": "",\n    "LineType": "",\n    "NominalCode": {\n      "@href": "",\n      "@rel": "",\n      "@title": ""\n    },\n    "TaxTreatment": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/CisLineTypes

import Foundation

let headers = [
  "authorization": "",
  "api-version": "",
  "content-type": "application/json"
]
let parameters = ["CisLineType": [
    "Description": "",
    "LineType": "",
    "NominalCode": [
      "@href": "",
      "@rel": "",
      "@title": ""
    ],
    "TaxTreatment": ""
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/CisLineTypes")! 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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId" {:headers {:authorization ""
                                                                                                                                             :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

DELETE /baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  method: 'DELETE',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"]
                                                       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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("DELETE", "/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"

response <- VERB("DELETE", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")

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

request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method DELETE \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId" {:headers {:authorization ""
                                                                                                                               :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

DELETE /baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId',
  method: 'DELETE',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"]
                                                       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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("DELETE", "/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"

response <- VERB("DELETE", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId")

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

request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method DELETE \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId" {:headers {:authorization ""
                                                                                                        :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

DELETE /baseUrl/Employer/:EmployerId/CisLineType/:CisLineTypeId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  method: 'DELETE',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"]
                                                       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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("DELETE", "/baseUrl/Employer/:EmployerId/CisLineType/:CisLineTypeId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"

response <- VERB("DELETE", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")

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

request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/Employer/:EmployerId/CisLineType/:CisLineTypeId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method DELETE \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId" {:headers {:authorization ""
                                                                                                              :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

DELETE /baseUrl/Employer/:EmployerId/CisTransaction/:CisTransactionId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId',
  method: 'DELETE',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/CisTransaction/:CisTransactionId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"]
                                                       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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId' -Method DELETE -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("DELETE", "/baseUrl/Employer/:EmployerId/CisTransaction/:CisTransactionId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"

response <- VERB("DELETE", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId")

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

request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/Employer/:EmployerId/CisTransaction/:CisTransactionId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method DELETE \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId")! 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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId" {:headers {:authorization ""
                                                                                                                                          :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"]
                                                       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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")! 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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions" {:headers {:authorization ""
                                                                                                                         :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"]
                                                       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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstructions")! 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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId" {:headers {:authorization ""
                                                                                                                            :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"]
                                                       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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLine/:CisLineId")! 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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId" {:headers {:authorization ""
                                                                                                     :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Employer/:EmployerId/CisLineType/:CisLineTypeId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"]
                                                       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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/CisLineType/:CisLineTypeId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Employer/:EmployerId/CisLineType/:CisLineTypeId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/CisLineType/:CisLineTypeId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")! 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}}/Employer/:EmployerId/CisLineTypes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Employer/:EmployerId/CisLineTypes" {:headers {:authorization ""
                                                                                       :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/CisLineTypes"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/CisLineTypes");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/CisLineTypes"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Employer/:EmployerId/CisLineTypes HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/CisLineTypes")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/CisLineTypes"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/CisLineTypes")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/CisLineTypes")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/CisLineTypes');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineTypes',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisLineTypes';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineTypes',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/CisLineTypes")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/CisLineTypes',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/CisLineTypes',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/CisLineTypes');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/CisLineTypes',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisLineTypes';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/CisLineTypes"]
                                                       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}}/Employer/:EmployerId/CisLineTypes" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/CisLineTypes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Employer/:EmployerId/CisLineTypes', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/CisLineTypes');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/CisLineTypes');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/CisLineTypes' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/CisLineTypes' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/CisLineTypes", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/CisLineTypes"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/CisLineTypes"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/CisLineTypes")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Employer/:EmployerId/CisLineTypes') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/CisLineTypes \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/CisLineTypes

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/CisLineTypes")! 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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines" {:headers {:authorization ""
                                                                                                                  :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines"]
                                                       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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisLines")! 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}}/Employer/:EmployerId/CisTransactions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Employer/:EmployerId/CisTransactions" {:headers {:authorization ""
                                                                                          :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/CisTransactions"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/CisTransactions");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/CisTransactions"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Employer/:EmployerId/CisTransactions HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/CisTransactions")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/CisTransactions"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/CisTransactions")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/CisTransactions")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/CisTransactions');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/CisTransactions',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisTransactions';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/CisTransactions',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/CisTransactions")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/CisTransactions',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/CisTransactions',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/CisTransactions');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/CisTransactions',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisTransactions';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/CisTransactions"]
                                                       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}}/Employer/:EmployerId/CisTransactions" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/CisTransactions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Employer/:EmployerId/CisTransactions', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/CisTransactions');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/CisTransactions');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/CisTransactions' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/CisTransactions' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/CisTransactions", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/CisTransactions"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/CisTransactions"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/CisTransactions")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Employer/:EmployerId/CisTransactions') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/CisTransactions \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/CisTransactions

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/CisTransactions")! 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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId" {:headers {:authorization ""
                                                                                                           :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

GET /baseUrl/Employer/:EmployerId/CisTransaction/:CisTransactionId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/CisTransaction/:CisTransactionId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId',
  headers: {authorization: '', 'api-version': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId',
  headers: {authorization: '', 'api-version': ''}
};

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

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

const url = '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"]
                                                       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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

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

 "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId' -Method GET -Headers $headers

import http.client

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

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/CisTransaction/:CisTransactionId", headers=headers)

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

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

import requests

url = "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"

headers = {
    "authorization": "",
    "api-version": ""
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/Employer/:EmployerId/CisTransaction/:CisTransactionId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/CisTransaction/:CisTransactionId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/CisTransaction/:CisTransactionId")! 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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId" {:headers {:authorization ""
                                                                                                                                            :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"

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

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

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

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

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

}

PATCH /baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"))
    .header("authorization", "")
    .header("api-version", "")
    .method("PATCH", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .patch(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .header("authorization", "")
  .header("api-version", "")
  .asString();

const data = null;

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

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

xhr.open('PATCH', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {authorization: '', 'api-version': ''}
};

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

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId';
const options = {method: 'PATCH', headers: {authorization: '', 'api-version': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  method: 'PATCH',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .patch(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

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

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId';
const options = {method: 'PATCH', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId' -Method PATCH -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId' -Method PATCH -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("PATCH", "/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.patch(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"

response <- VERB("PATCH", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PATCH {{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method PATCH \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId" {:headers {:authorization ""
                                                                                                                                          :api-version ""}
                                                                                                                                :content-type :json
                                                                                                                                :form-params {:CisInstruction {:CisLineTag ""
                                                                                                                                                               :CisLineType ""
                                                                                                                                                               :Description ""
                                                                                                                                                               :PayFrequency ""
                                                                                                                                                               :PeriodEnd 0
                                                                                                                                                               :PeriodStart 0
                                                                                                                                                               :TaxYearEnd 0
                                                                                                                                                               :TaxYearStart 0
                                                                                                                                                               :UOM ""
                                                                                                                                                               :Units ""
                                                                                                                                                               :VAT ""
                                                                                                                                                               :Value ""}}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
    Content = new StringContent("{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"

	payload := strings.NewReader("{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId HTTP/1.1
Authorization: 
Api-Version: 
Content-Type: application/json
Host: example.com
Content-Length: 270

{
  "CisInstruction": {
    "CisLineTag": "",
    "CisLineType": "",
    "Description": "",
    "PayFrequency": "",
    "PeriodEnd": 0,
    "PeriodStart": 0,
    "TaxYearEnd": 0,
    "TaxYearStart": 0,
    "UOM": "",
    "Units": "",
    "VAT": "",
    "Value": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"))
    .header("authorization", "")
    .header("api-version", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .put(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .header("authorization", "")
  .header("api-version", "")
  .header("content-type", "application/json")
  .body("{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  CisInstruction: {
    CisLineTag: '',
    CisLineType: '',
    Description: '',
    PayFrequency: '',
    PeriodEnd: 0,
    PeriodStart: 0,
    TaxYearEnd: 0,
    TaxYearStart: 0,
    UOM: '',
    Units: '',
    VAT: '',
    Value: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    CisInstruction: {
      CisLineTag: '',
      CisLineType: '',
      Description: '',
      PayFrequency: '',
      PeriodEnd: 0,
      PeriodStart: 0,
      TaxYearEnd: 0,
      TaxYearStart: 0,
      UOM: '',
      Units: '',
      VAT: '',
      Value: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId';
const options = {
  method: 'PUT',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"CisInstruction":{"CisLineTag":"","CisLineType":"","Description":"","PayFrequency":"","PeriodEnd":0,"PeriodStart":0,"TaxYearEnd":0,"TaxYearStart":0,"UOM":"","Units":"","VAT":"","Value":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  method: 'PUT',
  headers: {
    authorization: '',
    'api-version': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CisInstruction": {\n    "CisLineTag": "",\n    "CisLineType": "",\n    "Description": "",\n    "PayFrequency": "",\n    "PeriodEnd": 0,\n    "PeriodStart": 0,\n    "TaxYearEnd": 0,\n    "TaxYearStart": 0,\n    "UOM": "",\n    "Units": "",\n    "VAT": "",\n    "Value": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")
  .put(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {
    authorization: '',
    'api-version': '',
    '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({
  CisInstruction: {
    CisLineTag: '',
    CisLineType: '',
    Description: '',
    PayFrequency: '',
    PeriodEnd: 0,
    PeriodStart: 0,
    TaxYearEnd: 0,
    TaxYearStart: 0,
    UOM: '',
    Units: '',
    VAT: '',
    Value: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: {
    CisInstruction: {
      CisLineTag: '',
      CisLineType: '',
      Description: '',
      PayFrequency: '',
      PeriodEnd: 0,
      PeriodStart: 0,
      TaxYearEnd: 0,
      TaxYearStart: 0,
      UOM: '',
      Units: '',
      VAT: '',
      Value: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');

req.headers({
  authorization: '',
  'api-version': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  CisInstruction: {
    CisLineTag: '',
    CisLineType: '',
    Description: '',
    PayFrequency: '',
    PeriodEnd: 0,
    PeriodStart: 0,
    TaxYearEnd: 0,
    TaxYearStart: 0,
    UOM: '',
    Units: '',
    VAT: '',
    Value: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    CisInstruction: {
      CisLineTag: '',
      CisLineType: '',
      Description: '',
      PayFrequency: '',
      PeriodEnd: 0,
      PeriodStart: 0,
      TaxYearEnd: 0,
      TaxYearStart: 0,
      UOM: '',
      Units: '',
      VAT: '',
      Value: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId';
const options = {
  method: 'PUT',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"CisInstruction":{"CisLineTag":"","CisLineType":"","Description":"","PayFrequency":"","PeriodEnd":0,"PeriodStart":0,"TaxYearEnd":0,"TaxYearStart":0,"UOM":"","Units":"","VAT":"","Value":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"CisInstruction": @{ @"CisLineTag": @"", @"CisLineType": @"", @"Description": @"", @"PayFrequency": @"", @"PeriodEnd": @0, @"PeriodStart": @0, @"TaxYearEnd": @0, @"TaxYearStart": @0, @"UOM": @"", @"Units": @"", @"VAT": @"", @"Value": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'CisInstruction' => [
        'CisLineTag' => '',
        'CisLineType' => '',
        'Description' => '',
        'PayFrequency' => '',
        'PeriodEnd' => 0,
        'PeriodStart' => 0,
        'TaxYearEnd' => 0,
        'TaxYearStart' => 0,
        'UOM' => '',
        'Units' => '',
        'VAT' => '',
        'Value' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: ",
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId', [
  'body' => '{
  "CisInstruction": {
    "CisLineTag": "",
    "CisLineType": "",
    "Description": "",
    "PayFrequency": "",
    "PeriodEnd": 0,
    "PeriodStart": 0,
    "TaxYearEnd": 0,
    "TaxYearStart": 0,
    "UOM": "",
    "Units": "",
    "VAT": "",
    "Value": ""
  }
}',
  'headers' => [
    'api-version' => '',
    'authorization' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'authorization' => '',
  'api-version' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CisInstruction' => [
    'CisLineTag' => '',
    'CisLineType' => '',
    'Description' => '',
    'PayFrequency' => '',
    'PeriodEnd' => 0,
    'PeriodStart' => 0,
    'TaxYearEnd' => 0,
    'TaxYearStart' => 0,
    'UOM' => '',
    'Units' => '',
    'VAT' => '',
    'Value' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'CisInstruction' => [
    'CisLineTag' => '',
    'CisLineType' => '',
    'Description' => '',
    'PayFrequency' => '',
    'PeriodEnd' => 0,
    'PeriodStart' => 0,
    'TaxYearEnd' => 0,
    'TaxYearStart' => 0,
    'UOM' => '',
    'Units' => '',
    'VAT' => '',
    'Value' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'authorization' => '',
  'api-version' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "CisInstruction": {
    "CisLineTag": "",
    "CisLineType": "",
    "Description": "",
    "PayFrequency": "",
    "PeriodEnd": 0,
    "PeriodStart": 0,
    "TaxYearEnd": 0,
    "TaxYearStart": 0,
    "UOM": "",
    "Units": "",
    "VAT": "",
    "Value": ""
  }
}'

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "CisInstruction": {
    "CisLineTag": "",
    "CisLineType": "",
    "Description": "",
    "PayFrequency": "",
    "PeriodEnd": 0,
    "PeriodStart": 0,
    "TaxYearEnd": 0,
    "TaxYearStart": 0,
    "UOM": "",
    "Units": "",
    "VAT": "",
    "Value": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}"

headers = {
    'authorization': "",
    'api-version': "",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"

payload = { "CisInstruction": {
        "CisLineTag": "",
        "CisLineType": "",
        "Description": "",
        "PayFrequency": "",
        "PeriodEnd": 0,
        "PeriodStart": 0,
        "TaxYearEnd": 0,
        "TaxYearStart": 0,
        "UOM": "",
        "Units": "",
        "VAT": "",
        "Value": ""
    } }
headers = {
    "authorization": "",
    "api-version": "",
    "content-type": "application/json"
}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId"

payload <- "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('authorization' = '', 'api-version' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["api-version"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
  req.body = "{\n  \"CisInstruction\": {\n    \"CisLineTag\": \"\",\n    \"CisLineType\": \"\",\n    \"Description\": \"\",\n    \"PayFrequency\": \"\",\n    \"PeriodEnd\": 0,\n    \"PeriodStart\": 0,\n    \"TaxYearEnd\": 0,\n    \"TaxYearStart\": 0,\n    \"UOM\": \"\",\n    \"Units\": \"\",\n    \"VAT\": \"\",\n    \"Value\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId";

    let payload = json!({"CisInstruction": json!({
            "CisLineTag": "",
            "CisLineType": "",
            "Description": "",
            "PayFrequency": "",
            "PeriodEnd": 0,
            "PeriodStart": 0,
            "TaxYearEnd": 0,
            "TaxYearStart": 0,
            "UOM": "",
            "Units": "",
            "VAT": "",
            "Value": ""
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "CisInstruction": {
    "CisLineTag": "",
    "CisLineType": "",
    "Description": "",
    "PayFrequency": "",
    "PeriodEnd": 0,
    "PeriodStart": 0,
    "TaxYearEnd": 0,
    "TaxYearStart": 0,
    "UOM": "",
    "Units": "",
    "VAT": "",
    "Value": ""
  }
}' |  \
  http PUT {{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId \
  api-version:'' \
  authorization:'' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CisInstruction": {\n    "CisLineTag": "",\n    "CisLineType": "",\n    "Description": "",\n    "PayFrequency": "",\n    "PeriodEnd": 0,\n    "PeriodStart": 0,\n    "TaxYearEnd": 0,\n    "TaxYearStart": 0,\n    "UOM": "",\n    "Units": "",\n    "VAT": "",\n    "Value": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId

import Foundation

let headers = [
  "authorization": "",
  "api-version": "",
  "content-type": "application/json"
]
let parameters = ["CisInstruction": [
    "CisLineTag": "",
    "CisLineType": "",
    "Description": "",
    "PayFrequency": "",
    "PeriodEnd": 0,
    "PeriodStart": 0,
    "TaxYearEnd": 0,
    "TaxYearStart": 0,
    "UOM": "",
    "Units": "",
    "VAT": "",
    "Value": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/SubContractor/:SubContractorId/CisInstruction/:CisInstructionId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId" {:headers {:authorization ""
                                                                                                     :api-version ""}
                                                                                           :content-type :json
                                                                                           :form-params {:CisLineType {:Description ""
                                                                                                                       :LineType ""
                                                                                                                       :NominalCode {:@href ""
                                                                                                                                     :@rel ""
                                                                                                                                     :@title ""}
                                                                                                                       :TaxTreatment ""}}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
    Content = new StringContent("{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"

	payload := strings.NewReader("{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/Employer/:EmployerId/CisLineType/:CisLineTypeId HTTP/1.1
Authorization: 
Api-Version: 
Content-Type: application/json
Host: example.com
Content-Length: 176

{
  "CisLineType": {
    "Description": "",
    "LineType": "",
    "NominalCode": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "TaxTreatment": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"))
    .header("authorization", "")
    .header("api-version", "")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")
  .put(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")
  .header("authorization", "")
  .header("api-version", "")
  .header("content-type", "application/json")
  .body("{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  CisLineType: {
    Description: '',
    LineType: '',
    NominalCode: {
      '@href': '',
      '@rel': '',
      '@title': ''
    },
    TaxTreatment: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    CisLineType: {
      Description: '',
      LineType: '',
      NominalCode: {'@href': '', '@rel': '', '@title': ''},
      TaxTreatment: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId';
const options = {
  method: 'PUT',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"CisLineType":{"Description":"","LineType":"","NominalCode":{"@href":"","@rel":"","@title":""},"TaxTreatment":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  method: 'PUT',
  headers: {
    authorization: '',
    'api-version': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CisLineType": {\n    "Description": "",\n    "LineType": "",\n    "NominalCode": {\n      "@href": "",\n      "@rel": "",\n      "@title": ""\n    },\n    "TaxTreatment": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")
  .put(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  headers: {
    authorization: '',
    'api-version': '',
    '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({
  CisLineType: {
    Description: '',
    LineType: '',
    NominalCode: {'@href': '', '@rel': '', '@title': ''},
    TaxTreatment: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: {
    CisLineType: {
      Description: '',
      LineType: '',
      NominalCode: {'@href': '', '@rel': '', '@title': ''},
      TaxTreatment: ''
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId');

req.headers({
  authorization: '',
  'api-version': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  CisLineType: {
    Description: '',
    LineType: '',
    NominalCode: {
      '@href': '',
      '@rel': '',
      '@title': ''
    },
    TaxTreatment: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    CisLineType: {
      Description: '',
      LineType: '',
      NominalCode: {'@href': '', '@rel': '', '@title': ''},
      TaxTreatment: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId';
const options = {
  method: 'PUT',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"CisLineType":{"Description":"","LineType":"","NominalCode":{"@href":"","@rel":"","@title":""},"TaxTreatment":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"CisLineType": @{ @"Description": @"", @"LineType": @"", @"NominalCode": @{ @"@href": @"", @"@rel": @"", @"@title": @"" }, @"TaxTreatment": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'CisLineType' => [
        'Description' => '',
        'LineType' => '',
        'NominalCode' => [
                '@href' => '',
                '@rel' => '',
                '@title' => ''
        ],
        'TaxTreatment' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: ",
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId', [
  'body' => '{
  "CisLineType": {
    "Description": "",
    "LineType": "",
    "NominalCode": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "TaxTreatment": ""
  }
}',
  'headers' => [
    'api-version' => '',
    'authorization' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'authorization' => '',
  'api-version' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CisLineType' => [
    'Description' => '',
    'LineType' => '',
    'NominalCode' => [
        '@href' => '',
        '@rel' => '',
        '@title' => ''
    ],
    'TaxTreatment' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'CisLineType' => [
    'Description' => '',
    'LineType' => '',
    'NominalCode' => [
        '@href' => '',
        '@rel' => '',
        '@title' => ''
    ],
    'TaxTreatment' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'authorization' => '',
  'api-version' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "CisLineType": {
    "Description": "",
    "LineType": "",
    "NominalCode": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "TaxTreatment": ""
  }
}'

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "CisLineType": {
    "Description": "",
    "LineType": "",
    "NominalCode": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "TaxTreatment": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}"

headers = {
    'authorization': "",
    'api-version': "",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/Employer/:EmployerId/CisLineType/:CisLineTypeId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"

payload = { "CisLineType": {
        "Description": "",
        "LineType": "",
        "NominalCode": {
            "@href": "",
            "@rel": "",
            "@title": ""
        },
        "TaxTreatment": ""
    } }
headers = {
    "authorization": "",
    "api-version": "",
    "content-type": "application/json"
}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId"

payload <- "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('authorization' = '', 'api-version' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["api-version"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/Employer/:EmployerId/CisLineType/:CisLineTypeId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
  req.body = "{\n  \"CisLineType\": {\n    \"Description\": \"\",\n    \"LineType\": \"\",\n    \"NominalCode\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"TaxTreatment\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId";

    let payload = json!({"CisLineType": json!({
            "Description": "",
            "LineType": "",
            "NominalCode": json!({
                "@href": "",
                "@rel": "",
                "@title": ""
            }),
            "TaxTreatment": ""
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "CisLineType": {
    "Description": "",
    "LineType": "",
    "NominalCode": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "TaxTreatment": ""
  }
}' |  \
  http PUT {{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId \
  api-version:'' \
  authorization:'' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CisLineType": {\n    "Description": "",\n    "LineType": "",\n    "NominalCode": {\n      "@href": "",\n      "@rel": "",\n      "@title": ""\n    },\n    "TaxTreatment": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId

import Foundation

let headers = [
  "authorization": "",
  "api-version": "",
  "content-type": "application/json"
]
let parameters = ["CisLineType": [
    "Description": "",
    "LineType": "",
    "NominalCode": [
      "@href": "",
      "@rel": "",
      "@title": ""
    ],
    "TaxTreatment": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/CisLineType/:CisLineTypeId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId" {:headers {:authorization ""
                                                                                                      :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  method: 'DELETE',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"]
                                                       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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("DELETE", "/baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"

response <- VERB("DELETE", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method DELETE \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")! 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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId" {:headers {:authorization ""
                                                                                                   :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"]
                                                       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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")! 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}}/Employer/:EmployerId/DpsMessages");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/Employer/:EmployerId/DpsMessages" {:headers {:authorization ""
                                                                                      :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/DpsMessages"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/DpsMessages"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/DpsMessages");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/DpsMessages"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/Employer/:EmployerId/DpsMessages HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/DpsMessages")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/DpsMessages"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/DpsMessages")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/DpsMessages")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/DpsMessages');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessages',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/DpsMessages';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessages',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/DpsMessages")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/DpsMessages',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/DpsMessages',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/DpsMessages');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/DpsMessages',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/DpsMessages';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/DpsMessages"]
                                                       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}}/Employer/:EmployerId/DpsMessages" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/DpsMessages",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/Employer/:EmployerId/DpsMessages', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/DpsMessages');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/DpsMessages');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/DpsMessages' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/DpsMessages' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/DpsMessages", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/DpsMessages"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/DpsMessages"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/DpsMessages")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/Employer/:EmployerId/DpsMessages') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/DpsMessages";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/DpsMessages \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/DpsMessages

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/DpsMessages")! 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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId" {:headers {:authorization ""
                                                                                                     :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

response = HTTP::Client.patch url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"

	req, _ := http.NewRequest("PATCH", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"))
    .header("authorization", "")
    .header("api-version", "")
    .method("PATCH", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .patch(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .header("authorization", "")
  .header("api-version", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId';
const options = {method: 'PATCH', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  method: 'PATCH',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .patch(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId';
const options = {method: 'PATCH', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');
$request->setRequestMethod('PATCH');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId' -Method PATCH -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId' -Method PATCH -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("PATCH", "/baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.patch(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"

response <- VERB("PATCH", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PATCH {{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method PATCH \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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}}/Employer/:EmployerId/DpsMessages");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/Employer/:EmployerId/DpsMessages" {:headers {:authorization ""
                                                                                       :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/DpsMessages"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/DpsMessages"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/DpsMessages");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/DpsMessages"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/Employer/:EmployerId/DpsMessages HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/Employer/:EmployerId/DpsMessages")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/DpsMessages"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/DpsMessages")
  .post(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/Employer/:EmployerId/DpsMessages")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/DpsMessages');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessages',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/DpsMessages';
const options = {method: 'POST', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessages',
  method: 'POST',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/DpsMessages")
  .post(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/DpsMessages',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/DpsMessages',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/Employer/:EmployerId/DpsMessages');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/DpsMessages',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/DpsMessages';
const options = {method: 'POST', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/DpsMessages"]
                                                       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}}/Employer/:EmployerId/DpsMessages" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/DpsMessages",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/Employer/:EmployerId/DpsMessages', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/DpsMessages');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/DpsMessages');
$request->setRequestMethod('POST');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/DpsMessages' -Method POST -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/DpsMessages' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("POST", "/baseUrl/Employer/:EmployerId/DpsMessages", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/DpsMessages"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/DpsMessages"

response <- VERB("POST", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/DpsMessages")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/Employer/:EmployerId/DpsMessages') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/DpsMessages";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/DpsMessages \
  api-version:'' \
  authorization:''

wget --quiet \
  --method POST \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/DpsMessages

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/DpsMessages")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId" {:headers {:authorization ""
                                                                                                   :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"))
    .header("authorization", "")
    .header("api-version", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .put(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .header("authorization", "")
  .header("api-version", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId';
const options = {method: 'PUT', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  method: 'PUT',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")
  .put(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');

req.headers({
  authorization: '',
  'api-version': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId';
const options = {method: 'PUT', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/Employer/:EmployerId/DpsMessage/:DpsMessageId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId' -Method PUT -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("PUT", "/baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.put(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId"

response <- VERB("PUT", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/Employer/:EmployerId/DpsMessage/:DpsMessageId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PUT {{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method PUT \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/DpsMessage/:DpsMessageId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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}}/Employer/:EmployerId/Employees");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/Employer/:EmployerId/Employees" {:headers {:authorization ""
                                                                                     :api-version ""}
                                                                           :content-type :json
                                                                           :form-params {:Employee {:AEAssessmentOverride ""
                                                                                                    :AEAssessmentOverrideDate ""
                                                                                                    :AEExclusionReasonCode ""
                                                                                                    :AEPostponementDate ""
                                                                                                    :Address {:Address1 ""
                                                                                                              :Address2 ""
                                                                                                              :Address3 ""
                                                                                                              :Address4 ""
                                                                                                              :Country ""
                                                                                                              :Postcode ""}
                                                                                                    :BankAccount {:AccountName ""
                                                                                                                  :AccountNumber ""
                                                                                                                  :BranchName ""
                                                                                                                  :Reference ""
                                                                                                                  :SortCode ""}
                                                                                                    :Code ""
                                                                                                    :DateOfBirth ""
                                                                                                    :Deactivated false
                                                                                                    :DirectorshipAppointmentDate ""
                                                                                                    :EEACitizen false
                                                                                                    :EPM6 false
                                                                                                    :EffectiveDate ""
                                                                                                    :EmployeePartner {:FirstName ""
                                                                                                                      :Initials ""
                                                                                                                      :LastName ""
                                                                                                                      :MiddleName ""
                                                                                                                      :NiNumber ""}
                                                                                                    :FirstName ""
                                                                                                    :Gender ""
                                                                                                    :HoursPerWeek ""
                                                                                                    :Initials ""
                                                                                                    :IrregularEmployment false
                                                                                                    :IsAgencyWorker false
                                                                                                    :LastName ""
                                                                                                    :LeaverReason ""
                                                                                                    :LeavingDate ""
                                                                                                    :MaritalStatus ""
                                                                                                    :MetaData {}
                                                                                                    :MiddleName ""
                                                                                                    :NextRevisionDate ""
                                                                                                    :NiNumber ""
                                                                                                    :NicLiability ""
                                                                                                    :OffPayrollWorker false
                                                                                                    :OnStrike false
                                                                                                    :P45IssuedDate ""
                                                                                                    :PassportNumber ""
                                                                                                    :PaySchedule {:@href ""
                                                                                                                  :@rel ""
                                                                                                                  :@title ""}
                                                                                                    :PaymentMethod ""
                                                                                                    :PaymentToANonIndividual false
                                                                                                    :Region ""
                                                                                                    :Revision 0
                                                                                                    :RuleExclusions ""
                                                                                                    :Seconded ""
                                                                                                    :StartDate ""
                                                                                                    :StarterDeclaration ""
                                                                                                    :Territory ""
                                                                                                    :Title ""
                                                                                                    :VeteranPeriodStartDate ""
                                                                                                    :WorkingWeek ""}}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employees"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/Employer/:EmployerId/Employees"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
    Content = new StringContent("{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employees");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employees"

	payload := strings.NewReader("{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")
	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/Employer/:EmployerId/Employees HTTP/1.1
Authorization: 
Api-Version: 
Content-Type: application/json
Host: example.com
Content-Length: 1605

{
  "Employee": {
    "AEAssessmentOverride": "",
    "AEAssessmentOverrideDate": "",
    "AEExclusionReasonCode": "",
    "AEPostponementDate": "",
    "Address": {
      "Address1": "",
      "Address2": "",
      "Address3": "",
      "Address4": "",
      "Country": "",
      "Postcode": ""
    },
    "BankAccount": {
      "AccountName": "",
      "AccountNumber": "",
      "BranchName": "",
      "Reference": "",
      "SortCode": ""
    },
    "Code": "",
    "DateOfBirth": "",
    "Deactivated": false,
    "DirectorshipAppointmentDate": "",
    "EEACitizen": false,
    "EPM6": false,
    "EffectiveDate": "",
    "EmployeePartner": {
      "FirstName": "",
      "Initials": "",
      "LastName": "",
      "MiddleName": "",
      "NiNumber": ""
    },
    "FirstName": "",
    "Gender": "",
    "HoursPerWeek": "",
    "Initials": "",
    "IrregularEmployment": false,
    "IsAgencyWorker": false,
    "LastName": "",
    "LeaverReason": "",
    "LeavingDate": "",
    "MaritalStatus": "",
    "MetaData": {},
    "MiddleName": "",
    "NextRevisionDate": "",
    "NiNumber": "",
    "NicLiability": "",
    "OffPayrollWorker": false,
    "OnStrike": false,
    "P45IssuedDate": "",
    "PassportNumber": "",
    "PaySchedule": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "PaymentMethod": "",
    "PaymentToANonIndividual": false,
    "Region": "",
    "Revision": 0,
    "RuleExclusions": "",
    "Seconded": "",
    "StartDate": "",
    "StarterDeclaration": "",
    "Territory": "",
    "Title": "",
    "VeteranPeriodStartDate": "",
    "WorkingWeek": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/Employer/:EmployerId/Employees")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employees"))
    .header("authorization", "")
    .header("api-version", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employees")
  .post(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/Employer/:EmployerId/Employees")
  .header("authorization", "")
  .header("api-version", "")
  .header("content-type", "application/json")
  .body("{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Employee: {
    AEAssessmentOverride: '',
    AEAssessmentOverrideDate: '',
    AEExclusionReasonCode: '',
    AEPostponementDate: '',
    Address: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      Country: '',
      Postcode: ''
    },
    BankAccount: {
      AccountName: '',
      AccountNumber: '',
      BranchName: '',
      Reference: '',
      SortCode: ''
    },
    Code: '',
    DateOfBirth: '',
    Deactivated: false,
    DirectorshipAppointmentDate: '',
    EEACitizen: false,
    EPM6: false,
    EffectiveDate: '',
    EmployeePartner: {
      FirstName: '',
      Initials: '',
      LastName: '',
      MiddleName: '',
      NiNumber: ''
    },
    FirstName: '',
    Gender: '',
    HoursPerWeek: '',
    Initials: '',
    IrregularEmployment: false,
    IsAgencyWorker: false,
    LastName: '',
    LeaverReason: '',
    LeavingDate: '',
    MaritalStatus: '',
    MetaData: {},
    MiddleName: '',
    NextRevisionDate: '',
    NiNumber: '',
    NicLiability: '',
    OffPayrollWorker: false,
    OnStrike: false,
    P45IssuedDate: '',
    PassportNumber: '',
    PaySchedule: {
      '@href': '',
      '@rel': '',
      '@title': ''
    },
    PaymentMethod: '',
    PaymentToANonIndividual: false,
    Region: '',
    Revision: 0,
    RuleExclusions: '',
    Seconded: '',
    StartDate: '',
    StarterDeclaration: '',
    Territory: '',
    Title: '',
    VeteranPeriodStartDate: '',
    WorkingWeek: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/Employer/:EmployerId/Employees');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/Employer/:EmployerId/Employees',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    Employee: {
      AEAssessmentOverride: '',
      AEAssessmentOverrideDate: '',
      AEExclusionReasonCode: '',
      AEPostponementDate: '',
      Address: {
        Address1: '',
        Address2: '',
        Address3: '',
        Address4: '',
        Country: '',
        Postcode: ''
      },
      BankAccount: {
        AccountName: '',
        AccountNumber: '',
        BranchName: '',
        Reference: '',
        SortCode: ''
      },
      Code: '',
      DateOfBirth: '',
      Deactivated: false,
      DirectorshipAppointmentDate: '',
      EEACitizen: false,
      EPM6: false,
      EffectiveDate: '',
      EmployeePartner: {FirstName: '', Initials: '', LastName: '', MiddleName: '', NiNumber: ''},
      FirstName: '',
      Gender: '',
      HoursPerWeek: '',
      Initials: '',
      IrregularEmployment: false,
      IsAgencyWorker: false,
      LastName: '',
      LeaverReason: '',
      LeavingDate: '',
      MaritalStatus: '',
      MetaData: {},
      MiddleName: '',
      NextRevisionDate: '',
      NiNumber: '',
      NicLiability: '',
      OffPayrollWorker: false,
      OnStrike: false,
      P45IssuedDate: '',
      PassportNumber: '',
      PaySchedule: {'@href': '', '@rel': '', '@title': ''},
      PaymentMethod: '',
      PaymentToANonIndividual: false,
      Region: '',
      Revision: 0,
      RuleExclusions: '',
      Seconded: '',
      StartDate: '',
      StarterDeclaration: '',
      Territory: '',
      Title: '',
      VeteranPeriodStartDate: '',
      WorkingWeek: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employees';
const options = {
  method: 'POST',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"Employee":{"AEAssessmentOverride":"","AEAssessmentOverrideDate":"","AEExclusionReasonCode":"","AEPostponementDate":"","Address":{"Address1":"","Address2":"","Address3":"","Address4":"","Country":"","Postcode":""},"BankAccount":{"AccountName":"","AccountNumber":"","BranchName":"","Reference":"","SortCode":""},"Code":"","DateOfBirth":"","Deactivated":false,"DirectorshipAppointmentDate":"","EEACitizen":false,"EPM6":false,"EffectiveDate":"","EmployeePartner":{"FirstName":"","Initials":"","LastName":"","MiddleName":"","NiNumber":""},"FirstName":"","Gender":"","HoursPerWeek":"","Initials":"","IrregularEmployment":false,"IsAgencyWorker":false,"LastName":"","LeaverReason":"","LeavingDate":"","MaritalStatus":"","MetaData":{},"MiddleName":"","NextRevisionDate":"","NiNumber":"","NicLiability":"","OffPayrollWorker":false,"OnStrike":false,"P45IssuedDate":"","PassportNumber":"","PaySchedule":{"@href":"","@rel":"","@title":""},"PaymentMethod":"","PaymentToANonIndividual":false,"Region":"","Revision":0,"RuleExclusions":"","Seconded":"","StartDate":"","StarterDeclaration":"","Territory":"","Title":"","VeteranPeriodStartDate":"","WorkingWeek":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employees',
  method: 'POST',
  headers: {
    authorization: '',
    'api-version': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Employee": {\n    "AEAssessmentOverride": "",\n    "AEAssessmentOverrideDate": "",\n    "AEExclusionReasonCode": "",\n    "AEPostponementDate": "",\n    "Address": {\n      "Address1": "",\n      "Address2": "",\n      "Address3": "",\n      "Address4": "",\n      "Country": "",\n      "Postcode": ""\n    },\n    "BankAccount": {\n      "AccountName": "",\n      "AccountNumber": "",\n      "BranchName": "",\n      "Reference": "",\n      "SortCode": ""\n    },\n    "Code": "",\n    "DateOfBirth": "",\n    "Deactivated": false,\n    "DirectorshipAppointmentDate": "",\n    "EEACitizen": false,\n    "EPM6": false,\n    "EffectiveDate": "",\n    "EmployeePartner": {\n      "FirstName": "",\n      "Initials": "",\n      "LastName": "",\n      "MiddleName": "",\n      "NiNumber": ""\n    },\n    "FirstName": "",\n    "Gender": "",\n    "HoursPerWeek": "",\n    "Initials": "",\n    "IrregularEmployment": false,\n    "IsAgencyWorker": false,\n    "LastName": "",\n    "LeaverReason": "",\n    "LeavingDate": "",\n    "MaritalStatus": "",\n    "MetaData": {},\n    "MiddleName": "",\n    "NextRevisionDate": "",\n    "NiNumber": "",\n    "NicLiability": "",\n    "OffPayrollWorker": false,\n    "OnStrike": false,\n    "P45IssuedDate": "",\n    "PassportNumber": "",\n    "PaySchedule": {\n      "@href": "",\n      "@rel": "",\n      "@title": ""\n    },\n    "PaymentMethod": "",\n    "PaymentToANonIndividual": false,\n    "Region": "",\n    "Revision": 0,\n    "RuleExclusions": "",\n    "Seconded": "",\n    "StartDate": "",\n    "StarterDeclaration": "",\n    "Territory": "",\n    "Title": "",\n    "VeteranPeriodStartDate": "",\n    "WorkingWeek": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employees")
  .post(body)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .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/Employer/:EmployerId/Employees',
  headers: {
    authorization: '',
    'api-version': '',
    '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({
  Employee: {
    AEAssessmentOverride: '',
    AEAssessmentOverrideDate: '',
    AEExclusionReasonCode: '',
    AEPostponementDate: '',
    Address: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      Country: '',
      Postcode: ''
    },
    BankAccount: {
      AccountName: '',
      AccountNumber: '',
      BranchName: '',
      Reference: '',
      SortCode: ''
    },
    Code: '',
    DateOfBirth: '',
    Deactivated: false,
    DirectorshipAppointmentDate: '',
    EEACitizen: false,
    EPM6: false,
    EffectiveDate: '',
    EmployeePartner: {FirstName: '', Initials: '', LastName: '', MiddleName: '', NiNumber: ''},
    FirstName: '',
    Gender: '',
    HoursPerWeek: '',
    Initials: '',
    IrregularEmployment: false,
    IsAgencyWorker: false,
    LastName: '',
    LeaverReason: '',
    LeavingDate: '',
    MaritalStatus: '',
    MetaData: {},
    MiddleName: '',
    NextRevisionDate: '',
    NiNumber: '',
    NicLiability: '',
    OffPayrollWorker: false,
    OnStrike: false,
    P45IssuedDate: '',
    PassportNumber: '',
    PaySchedule: {'@href': '', '@rel': '', '@title': ''},
    PaymentMethod: '',
    PaymentToANonIndividual: false,
    Region: '',
    Revision: 0,
    RuleExclusions: '',
    Seconded: '',
    StartDate: '',
    StarterDeclaration: '',
    Territory: '',
    Title: '',
    VeteranPeriodStartDate: '',
    WorkingWeek: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/Employer/:EmployerId/Employees',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: {
    Employee: {
      AEAssessmentOverride: '',
      AEAssessmentOverrideDate: '',
      AEExclusionReasonCode: '',
      AEPostponementDate: '',
      Address: {
        Address1: '',
        Address2: '',
        Address3: '',
        Address4: '',
        Country: '',
        Postcode: ''
      },
      BankAccount: {
        AccountName: '',
        AccountNumber: '',
        BranchName: '',
        Reference: '',
        SortCode: ''
      },
      Code: '',
      DateOfBirth: '',
      Deactivated: false,
      DirectorshipAppointmentDate: '',
      EEACitizen: false,
      EPM6: false,
      EffectiveDate: '',
      EmployeePartner: {FirstName: '', Initials: '', LastName: '', MiddleName: '', NiNumber: ''},
      FirstName: '',
      Gender: '',
      HoursPerWeek: '',
      Initials: '',
      IrregularEmployment: false,
      IsAgencyWorker: false,
      LastName: '',
      LeaverReason: '',
      LeavingDate: '',
      MaritalStatus: '',
      MetaData: {},
      MiddleName: '',
      NextRevisionDate: '',
      NiNumber: '',
      NicLiability: '',
      OffPayrollWorker: false,
      OnStrike: false,
      P45IssuedDate: '',
      PassportNumber: '',
      PaySchedule: {'@href': '', '@rel': '', '@title': ''},
      PaymentMethod: '',
      PaymentToANonIndividual: false,
      Region: '',
      Revision: 0,
      RuleExclusions: '',
      Seconded: '',
      StartDate: '',
      StarterDeclaration: '',
      Territory: '',
      Title: '',
      VeteranPeriodStartDate: '',
      WorkingWeek: ''
    }
  },
  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}}/Employer/:EmployerId/Employees');

req.headers({
  authorization: '',
  'api-version': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Employee: {
    AEAssessmentOverride: '',
    AEAssessmentOverrideDate: '',
    AEExclusionReasonCode: '',
    AEPostponementDate: '',
    Address: {
      Address1: '',
      Address2: '',
      Address3: '',
      Address4: '',
      Country: '',
      Postcode: ''
    },
    BankAccount: {
      AccountName: '',
      AccountNumber: '',
      BranchName: '',
      Reference: '',
      SortCode: ''
    },
    Code: '',
    DateOfBirth: '',
    Deactivated: false,
    DirectorshipAppointmentDate: '',
    EEACitizen: false,
    EPM6: false,
    EffectiveDate: '',
    EmployeePartner: {
      FirstName: '',
      Initials: '',
      LastName: '',
      MiddleName: '',
      NiNumber: ''
    },
    FirstName: '',
    Gender: '',
    HoursPerWeek: '',
    Initials: '',
    IrregularEmployment: false,
    IsAgencyWorker: false,
    LastName: '',
    LeaverReason: '',
    LeavingDate: '',
    MaritalStatus: '',
    MetaData: {},
    MiddleName: '',
    NextRevisionDate: '',
    NiNumber: '',
    NicLiability: '',
    OffPayrollWorker: false,
    OnStrike: false,
    P45IssuedDate: '',
    PassportNumber: '',
    PaySchedule: {
      '@href': '',
      '@rel': '',
      '@title': ''
    },
    PaymentMethod: '',
    PaymentToANonIndividual: false,
    Region: '',
    Revision: 0,
    RuleExclusions: '',
    Seconded: '',
    StartDate: '',
    StarterDeclaration: '',
    Territory: '',
    Title: '',
    VeteranPeriodStartDate: '',
    WorkingWeek: ''
  }
});

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}}/Employer/:EmployerId/Employees',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  data: {
    Employee: {
      AEAssessmentOverride: '',
      AEAssessmentOverrideDate: '',
      AEExclusionReasonCode: '',
      AEPostponementDate: '',
      Address: {
        Address1: '',
        Address2: '',
        Address3: '',
        Address4: '',
        Country: '',
        Postcode: ''
      },
      BankAccount: {
        AccountName: '',
        AccountNumber: '',
        BranchName: '',
        Reference: '',
        SortCode: ''
      },
      Code: '',
      DateOfBirth: '',
      Deactivated: false,
      DirectorshipAppointmentDate: '',
      EEACitizen: false,
      EPM6: false,
      EffectiveDate: '',
      EmployeePartner: {FirstName: '', Initials: '', LastName: '', MiddleName: '', NiNumber: ''},
      FirstName: '',
      Gender: '',
      HoursPerWeek: '',
      Initials: '',
      IrregularEmployment: false,
      IsAgencyWorker: false,
      LastName: '',
      LeaverReason: '',
      LeavingDate: '',
      MaritalStatus: '',
      MetaData: {},
      MiddleName: '',
      NextRevisionDate: '',
      NiNumber: '',
      NicLiability: '',
      OffPayrollWorker: false,
      OnStrike: false,
      P45IssuedDate: '',
      PassportNumber: '',
      PaySchedule: {'@href': '', '@rel': '', '@title': ''},
      PaymentMethod: '',
      PaymentToANonIndividual: false,
      Region: '',
      Revision: 0,
      RuleExclusions: '',
      Seconded: '',
      StartDate: '',
      StarterDeclaration: '',
      Territory: '',
      Title: '',
      VeteranPeriodStartDate: '',
      WorkingWeek: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employees';
const options = {
  method: 'POST',
  headers: {authorization: '', 'api-version': '', 'content-type': 'application/json'},
  body: '{"Employee":{"AEAssessmentOverride":"","AEAssessmentOverrideDate":"","AEExclusionReasonCode":"","AEPostponementDate":"","Address":{"Address1":"","Address2":"","Address3":"","Address4":"","Country":"","Postcode":""},"BankAccount":{"AccountName":"","AccountNumber":"","BranchName":"","Reference":"","SortCode":""},"Code":"","DateOfBirth":"","Deactivated":false,"DirectorshipAppointmentDate":"","EEACitizen":false,"EPM6":false,"EffectiveDate":"","EmployeePartner":{"FirstName":"","Initials":"","LastName":"","MiddleName":"","NiNumber":""},"FirstName":"","Gender":"","HoursPerWeek":"","Initials":"","IrregularEmployment":false,"IsAgencyWorker":false,"LastName":"","LeaverReason":"","LeavingDate":"","MaritalStatus":"","MetaData":{},"MiddleName":"","NextRevisionDate":"","NiNumber":"","NicLiability":"","OffPayrollWorker":false,"OnStrike":false,"P45IssuedDate":"","PassportNumber":"","PaySchedule":{"@href":"","@rel":"","@title":""},"PaymentMethod":"","PaymentToANonIndividual":false,"Region":"","Revision":0,"RuleExclusions":"","Seconded":"","StartDate":"","StarterDeclaration":"","Territory":"","Title":"","VeteranPeriodStartDate":"","WorkingWeek":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Employee": @{ @"AEAssessmentOverride": @"", @"AEAssessmentOverrideDate": @"", @"AEExclusionReasonCode": @"", @"AEPostponementDate": @"", @"Address": @{ @"Address1": @"", @"Address2": @"", @"Address3": @"", @"Address4": @"", @"Country": @"", @"Postcode": @"" }, @"BankAccount": @{ @"AccountName": @"", @"AccountNumber": @"", @"BranchName": @"", @"Reference": @"", @"SortCode": @"" }, @"Code": @"", @"DateOfBirth": @"", @"Deactivated": @NO, @"DirectorshipAppointmentDate": @"", @"EEACitizen": @NO, @"EPM6": @NO, @"EffectiveDate": @"", @"EmployeePartner": @{ @"FirstName": @"", @"Initials": @"", @"LastName": @"", @"MiddleName": @"", @"NiNumber": @"" }, @"FirstName": @"", @"Gender": @"", @"HoursPerWeek": @"", @"Initials": @"", @"IrregularEmployment": @NO, @"IsAgencyWorker": @NO, @"LastName": @"", @"LeaverReason": @"", @"LeavingDate": @"", @"MaritalStatus": @"", @"MetaData": @{  }, @"MiddleName": @"", @"NextRevisionDate": @"", @"NiNumber": @"", @"NicLiability": @"", @"OffPayrollWorker": @NO, @"OnStrike": @NO, @"P45IssuedDate": @"", @"PassportNumber": @"", @"PaySchedule": @{ @"@href": @"", @"@rel": @"", @"@title": @"" }, @"PaymentMethod": @"", @"PaymentToANonIndividual": @NO, @"Region": @"", @"Revision": @0, @"RuleExclusions": @"", @"Seconded": @"", @"StartDate": @"", @"StarterDeclaration": @"", @"Territory": @"", @"Title": @"", @"VeteranPeriodStartDate": @"", @"WorkingWeek": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employees"]
                                                       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}}/Employer/:EmployerId/Employees" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employees",
  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([
    'Employee' => [
        'AEAssessmentOverride' => '',
        'AEAssessmentOverrideDate' => '',
        'AEExclusionReasonCode' => '',
        'AEPostponementDate' => '',
        'Address' => [
                'Address1' => '',
                'Address2' => '',
                'Address3' => '',
                'Address4' => '',
                'Country' => '',
                'Postcode' => ''
        ],
        'BankAccount' => [
                'AccountName' => '',
                'AccountNumber' => '',
                'BranchName' => '',
                'Reference' => '',
                'SortCode' => ''
        ],
        'Code' => '',
        'DateOfBirth' => '',
        'Deactivated' => null,
        'DirectorshipAppointmentDate' => '',
        'EEACitizen' => null,
        'EPM6' => null,
        'EffectiveDate' => '',
        'EmployeePartner' => [
                'FirstName' => '',
                'Initials' => '',
                'LastName' => '',
                'MiddleName' => '',
                'NiNumber' => ''
        ],
        'FirstName' => '',
        'Gender' => '',
        'HoursPerWeek' => '',
        'Initials' => '',
        'IrregularEmployment' => null,
        'IsAgencyWorker' => null,
        'LastName' => '',
        'LeaverReason' => '',
        'LeavingDate' => '',
        'MaritalStatus' => '',
        'MetaData' => [
                
        ],
        'MiddleName' => '',
        'NextRevisionDate' => '',
        'NiNumber' => '',
        'NicLiability' => '',
        'OffPayrollWorker' => null,
        'OnStrike' => null,
        'P45IssuedDate' => '',
        'PassportNumber' => '',
        'PaySchedule' => [
                '@href' => '',
                '@rel' => '',
                '@title' => ''
        ],
        'PaymentMethod' => '',
        'PaymentToANonIndividual' => null,
        'Region' => '',
        'Revision' => 0,
        'RuleExclusions' => '',
        'Seconded' => '',
        'StartDate' => '',
        'StarterDeclaration' => '',
        'Territory' => '',
        'Title' => '',
        'VeteranPeriodStartDate' => '',
        'WorkingWeek' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: ",
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/Employer/:EmployerId/Employees', [
  'body' => '{
  "Employee": {
    "AEAssessmentOverride": "",
    "AEAssessmentOverrideDate": "",
    "AEExclusionReasonCode": "",
    "AEPostponementDate": "",
    "Address": {
      "Address1": "",
      "Address2": "",
      "Address3": "",
      "Address4": "",
      "Country": "",
      "Postcode": ""
    },
    "BankAccount": {
      "AccountName": "",
      "AccountNumber": "",
      "BranchName": "",
      "Reference": "",
      "SortCode": ""
    },
    "Code": "",
    "DateOfBirth": "",
    "Deactivated": false,
    "DirectorshipAppointmentDate": "",
    "EEACitizen": false,
    "EPM6": false,
    "EffectiveDate": "",
    "EmployeePartner": {
      "FirstName": "",
      "Initials": "",
      "LastName": "",
      "MiddleName": "",
      "NiNumber": ""
    },
    "FirstName": "",
    "Gender": "",
    "HoursPerWeek": "",
    "Initials": "",
    "IrregularEmployment": false,
    "IsAgencyWorker": false,
    "LastName": "",
    "LeaverReason": "",
    "LeavingDate": "",
    "MaritalStatus": "",
    "MetaData": {},
    "MiddleName": "",
    "NextRevisionDate": "",
    "NiNumber": "",
    "NicLiability": "",
    "OffPayrollWorker": false,
    "OnStrike": false,
    "P45IssuedDate": "",
    "PassportNumber": "",
    "PaySchedule": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "PaymentMethod": "",
    "PaymentToANonIndividual": false,
    "Region": "",
    "Revision": 0,
    "RuleExclusions": "",
    "Seconded": "",
    "StartDate": "",
    "StarterDeclaration": "",
    "Territory": "",
    "Title": "",
    "VeteranPeriodStartDate": "",
    "WorkingWeek": ""
  }
}',
  'headers' => [
    'api-version' => '',
    'authorization' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employees');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'authorization' => '',
  'api-version' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Employee' => [
    'AEAssessmentOverride' => '',
    'AEAssessmentOverrideDate' => '',
    'AEExclusionReasonCode' => '',
    'AEPostponementDate' => '',
    'Address' => [
        'Address1' => '',
        'Address2' => '',
        'Address3' => '',
        'Address4' => '',
        'Country' => '',
        'Postcode' => ''
    ],
    'BankAccount' => [
        'AccountName' => '',
        'AccountNumber' => '',
        'BranchName' => '',
        'Reference' => '',
        'SortCode' => ''
    ],
    'Code' => '',
    'DateOfBirth' => '',
    'Deactivated' => null,
    'DirectorshipAppointmentDate' => '',
    'EEACitizen' => null,
    'EPM6' => null,
    'EffectiveDate' => '',
    'EmployeePartner' => [
        'FirstName' => '',
        'Initials' => '',
        'LastName' => '',
        'MiddleName' => '',
        'NiNumber' => ''
    ],
    'FirstName' => '',
    'Gender' => '',
    'HoursPerWeek' => '',
    'Initials' => '',
    'IrregularEmployment' => null,
    'IsAgencyWorker' => null,
    'LastName' => '',
    'LeaverReason' => '',
    'LeavingDate' => '',
    'MaritalStatus' => '',
    'MetaData' => [
        
    ],
    'MiddleName' => '',
    'NextRevisionDate' => '',
    'NiNumber' => '',
    'NicLiability' => '',
    'OffPayrollWorker' => null,
    'OnStrike' => null,
    'P45IssuedDate' => '',
    'PassportNumber' => '',
    'PaySchedule' => [
        '@href' => '',
        '@rel' => '',
        '@title' => ''
    ],
    'PaymentMethod' => '',
    'PaymentToANonIndividual' => null,
    'Region' => '',
    'Revision' => 0,
    'RuleExclusions' => '',
    'Seconded' => '',
    'StartDate' => '',
    'StarterDeclaration' => '',
    'Territory' => '',
    'Title' => '',
    'VeteranPeriodStartDate' => '',
    'WorkingWeek' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Employee' => [
    'AEAssessmentOverride' => '',
    'AEAssessmentOverrideDate' => '',
    'AEExclusionReasonCode' => '',
    'AEPostponementDate' => '',
    'Address' => [
        'Address1' => '',
        'Address2' => '',
        'Address3' => '',
        'Address4' => '',
        'Country' => '',
        'Postcode' => ''
    ],
    'BankAccount' => [
        'AccountName' => '',
        'AccountNumber' => '',
        'BranchName' => '',
        'Reference' => '',
        'SortCode' => ''
    ],
    'Code' => '',
    'DateOfBirth' => '',
    'Deactivated' => null,
    'DirectorshipAppointmentDate' => '',
    'EEACitizen' => null,
    'EPM6' => null,
    'EffectiveDate' => '',
    'EmployeePartner' => [
        'FirstName' => '',
        'Initials' => '',
        'LastName' => '',
        'MiddleName' => '',
        'NiNumber' => ''
    ],
    'FirstName' => '',
    'Gender' => '',
    'HoursPerWeek' => '',
    'Initials' => '',
    'IrregularEmployment' => null,
    'IsAgencyWorker' => null,
    'LastName' => '',
    'LeaverReason' => '',
    'LeavingDate' => '',
    'MaritalStatus' => '',
    'MetaData' => [
        
    ],
    'MiddleName' => '',
    'NextRevisionDate' => '',
    'NiNumber' => '',
    'NicLiability' => '',
    'OffPayrollWorker' => null,
    'OnStrike' => null,
    'P45IssuedDate' => '',
    'PassportNumber' => '',
    'PaySchedule' => [
        '@href' => '',
        '@rel' => '',
        '@title' => ''
    ],
    'PaymentMethod' => '',
    'PaymentToANonIndividual' => null,
    'Region' => '',
    'Revision' => 0,
    'RuleExclusions' => '',
    'Seconded' => '',
    'StartDate' => '',
    'StarterDeclaration' => '',
    'Territory' => '',
    'Title' => '',
    'VeteranPeriodStartDate' => '',
    'WorkingWeek' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employees');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'authorization' => '',
  'api-version' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employees' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Employee": {
    "AEAssessmentOverride": "",
    "AEAssessmentOverrideDate": "",
    "AEExclusionReasonCode": "",
    "AEPostponementDate": "",
    "Address": {
      "Address1": "",
      "Address2": "",
      "Address3": "",
      "Address4": "",
      "Country": "",
      "Postcode": ""
    },
    "BankAccount": {
      "AccountName": "",
      "AccountNumber": "",
      "BranchName": "",
      "Reference": "",
      "SortCode": ""
    },
    "Code": "",
    "DateOfBirth": "",
    "Deactivated": false,
    "DirectorshipAppointmentDate": "",
    "EEACitizen": false,
    "EPM6": false,
    "EffectiveDate": "",
    "EmployeePartner": {
      "FirstName": "",
      "Initials": "",
      "LastName": "",
      "MiddleName": "",
      "NiNumber": ""
    },
    "FirstName": "",
    "Gender": "",
    "HoursPerWeek": "",
    "Initials": "",
    "IrregularEmployment": false,
    "IsAgencyWorker": false,
    "LastName": "",
    "LeaverReason": "",
    "LeavingDate": "",
    "MaritalStatus": "",
    "MetaData": {},
    "MiddleName": "",
    "NextRevisionDate": "",
    "NiNumber": "",
    "NicLiability": "",
    "OffPayrollWorker": false,
    "OnStrike": false,
    "P45IssuedDate": "",
    "PassportNumber": "",
    "PaySchedule": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "PaymentMethod": "",
    "PaymentToANonIndividual": false,
    "Region": "",
    "Revision": 0,
    "RuleExclusions": "",
    "Seconded": "",
    "StartDate": "",
    "StarterDeclaration": "",
    "Territory": "",
    "Title": "",
    "VeteranPeriodStartDate": "",
    "WorkingWeek": ""
  }
}'

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employees' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Employee": {
    "AEAssessmentOverride": "",
    "AEAssessmentOverrideDate": "",
    "AEExclusionReasonCode": "",
    "AEPostponementDate": "",
    "Address": {
      "Address1": "",
      "Address2": "",
      "Address3": "",
      "Address4": "",
      "Country": "",
      "Postcode": ""
    },
    "BankAccount": {
      "AccountName": "",
      "AccountNumber": "",
      "BranchName": "",
      "Reference": "",
      "SortCode": ""
    },
    "Code": "",
    "DateOfBirth": "",
    "Deactivated": false,
    "DirectorshipAppointmentDate": "",
    "EEACitizen": false,
    "EPM6": false,
    "EffectiveDate": "",
    "EmployeePartner": {
      "FirstName": "",
      "Initials": "",
      "LastName": "",
      "MiddleName": "",
      "NiNumber": ""
    },
    "FirstName": "",
    "Gender": "",
    "HoursPerWeek": "",
    "Initials": "",
    "IrregularEmployment": false,
    "IsAgencyWorker": false,
    "LastName": "",
    "LeaverReason": "",
    "LeavingDate": "",
    "MaritalStatus": "",
    "MetaData": {},
    "MiddleName": "",
    "NextRevisionDate": "",
    "NiNumber": "",
    "NicLiability": "",
    "OffPayrollWorker": false,
    "OnStrike": false,
    "P45IssuedDate": "",
    "PassportNumber": "",
    "PaySchedule": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "PaymentMethod": "",
    "PaymentToANonIndividual": false,
    "Region": "",
    "Revision": 0,
    "RuleExclusions": "",
    "Seconded": "",
    "StartDate": "",
    "StarterDeclaration": "",
    "Territory": "",
    "Title": "",
    "VeteranPeriodStartDate": "",
    "WorkingWeek": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}"

headers = {
    'authorization': "",
    'api-version': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/Employer/:EmployerId/Employees", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employees"

payload = { "Employee": {
        "AEAssessmentOverride": "",
        "AEAssessmentOverrideDate": "",
        "AEExclusionReasonCode": "",
        "AEPostponementDate": "",
        "Address": {
            "Address1": "",
            "Address2": "",
            "Address3": "",
            "Address4": "",
            "Country": "",
            "Postcode": ""
        },
        "BankAccount": {
            "AccountName": "",
            "AccountNumber": "",
            "BranchName": "",
            "Reference": "",
            "SortCode": ""
        },
        "Code": "",
        "DateOfBirth": "",
        "Deactivated": False,
        "DirectorshipAppointmentDate": "",
        "EEACitizen": False,
        "EPM6": False,
        "EffectiveDate": "",
        "EmployeePartner": {
            "FirstName": "",
            "Initials": "",
            "LastName": "",
            "MiddleName": "",
            "NiNumber": ""
        },
        "FirstName": "",
        "Gender": "",
        "HoursPerWeek": "",
        "Initials": "",
        "IrregularEmployment": False,
        "IsAgencyWorker": False,
        "LastName": "",
        "LeaverReason": "",
        "LeavingDate": "",
        "MaritalStatus": "",
        "MetaData": {},
        "MiddleName": "",
        "NextRevisionDate": "",
        "NiNumber": "",
        "NicLiability": "",
        "OffPayrollWorker": False,
        "OnStrike": False,
        "P45IssuedDate": "",
        "PassportNumber": "",
        "PaySchedule": {
            "@href": "",
            "@rel": "",
            "@title": ""
        },
        "PaymentMethod": "",
        "PaymentToANonIndividual": False,
        "Region": "",
        "Revision": 0,
        "RuleExclusions": "",
        "Seconded": "",
        "StartDate": "",
        "StarterDeclaration": "",
        "Territory": "",
        "Title": "",
        "VeteranPeriodStartDate": "",
        "WorkingWeek": ""
    } }
headers = {
    "authorization": "",
    "api-version": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employees"

payload <- "{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('authorization' = '', 'api-version' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employees")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["api-version"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/Employer/:EmployerId/Employees') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
  req.body = "{\n  \"Employee\": {\n    \"AEAssessmentOverride\": \"\",\n    \"AEAssessmentOverrideDate\": \"\",\n    \"AEExclusionReasonCode\": \"\",\n    \"AEPostponementDate\": \"\",\n    \"Address\": {\n      \"Address1\": \"\",\n      \"Address2\": \"\",\n      \"Address3\": \"\",\n      \"Address4\": \"\",\n      \"Country\": \"\",\n      \"Postcode\": \"\"\n    },\n    \"BankAccount\": {\n      \"AccountName\": \"\",\n      \"AccountNumber\": \"\",\n      \"BranchName\": \"\",\n      \"Reference\": \"\",\n      \"SortCode\": \"\"\n    },\n    \"Code\": \"\",\n    \"DateOfBirth\": \"\",\n    \"Deactivated\": false,\n    \"DirectorshipAppointmentDate\": \"\",\n    \"EEACitizen\": false,\n    \"EPM6\": false,\n    \"EffectiveDate\": \"\",\n    \"EmployeePartner\": {\n      \"FirstName\": \"\",\n      \"Initials\": \"\",\n      \"LastName\": \"\",\n      \"MiddleName\": \"\",\n      \"NiNumber\": \"\"\n    },\n    \"FirstName\": \"\",\n    \"Gender\": \"\",\n    \"HoursPerWeek\": \"\",\n    \"Initials\": \"\",\n    \"IrregularEmployment\": false,\n    \"IsAgencyWorker\": false,\n    \"LastName\": \"\",\n    \"LeaverReason\": \"\",\n    \"LeavingDate\": \"\",\n    \"MaritalStatus\": \"\",\n    \"MetaData\": {},\n    \"MiddleName\": \"\",\n    \"NextRevisionDate\": \"\",\n    \"NiNumber\": \"\",\n    \"NicLiability\": \"\",\n    \"OffPayrollWorker\": false,\n    \"OnStrike\": false,\n    \"P45IssuedDate\": \"\",\n    \"PassportNumber\": \"\",\n    \"PaySchedule\": {\n      \"@href\": \"\",\n      \"@rel\": \"\",\n      \"@title\": \"\"\n    },\n    \"PaymentMethod\": \"\",\n    \"PaymentToANonIndividual\": false,\n    \"Region\": \"\",\n    \"Revision\": 0,\n    \"RuleExclusions\": \"\",\n    \"Seconded\": \"\",\n    \"StartDate\": \"\",\n    \"StarterDeclaration\": \"\",\n    \"Territory\": \"\",\n    \"Title\": \"\",\n    \"VeteranPeriodStartDate\": \"\",\n    \"WorkingWeek\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employees";

    let payload = json!({"Employee": json!({
            "AEAssessmentOverride": "",
            "AEAssessmentOverrideDate": "",
            "AEExclusionReasonCode": "",
            "AEPostponementDate": "",
            "Address": json!({
                "Address1": "",
                "Address2": "",
                "Address3": "",
                "Address4": "",
                "Country": "",
                "Postcode": ""
            }),
            "BankAccount": json!({
                "AccountName": "",
                "AccountNumber": "",
                "BranchName": "",
                "Reference": "",
                "SortCode": ""
            }),
            "Code": "",
            "DateOfBirth": "",
            "Deactivated": false,
            "DirectorshipAppointmentDate": "",
            "EEACitizen": false,
            "EPM6": false,
            "EffectiveDate": "",
            "EmployeePartner": json!({
                "FirstName": "",
                "Initials": "",
                "LastName": "",
                "MiddleName": "",
                "NiNumber": ""
            }),
            "FirstName": "",
            "Gender": "",
            "HoursPerWeek": "",
            "Initials": "",
            "IrregularEmployment": false,
            "IsAgencyWorker": false,
            "LastName": "",
            "LeaverReason": "",
            "LeavingDate": "",
            "MaritalStatus": "",
            "MetaData": json!({}),
            "MiddleName": "",
            "NextRevisionDate": "",
            "NiNumber": "",
            "NicLiability": "",
            "OffPayrollWorker": false,
            "OnStrike": false,
            "P45IssuedDate": "",
            "PassportNumber": "",
            "PaySchedule": json!({
                "@href": "",
                "@rel": "",
                "@title": ""
            }),
            "PaymentMethod": "",
            "PaymentToANonIndividual": false,
            "Region": "",
            "Revision": 0,
            "RuleExclusions": "",
            "Seconded": "",
            "StartDate": "",
            "StarterDeclaration": "",
            "Territory": "",
            "Title": "",
            "VeteranPeriodStartDate": "",
            "WorkingWeek": ""
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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 '{
  "Employee": {
    "AEAssessmentOverride": "",
    "AEAssessmentOverrideDate": "",
    "AEExclusionReasonCode": "",
    "AEPostponementDate": "",
    "Address": {
      "Address1": "",
      "Address2": "",
      "Address3": "",
      "Address4": "",
      "Country": "",
      "Postcode": ""
    },
    "BankAccount": {
      "AccountName": "",
      "AccountNumber": "",
      "BranchName": "",
      "Reference": "",
      "SortCode": ""
    },
    "Code": "",
    "DateOfBirth": "",
    "Deactivated": false,
    "DirectorshipAppointmentDate": "",
    "EEACitizen": false,
    "EPM6": false,
    "EffectiveDate": "",
    "EmployeePartner": {
      "FirstName": "",
      "Initials": "",
      "LastName": "",
      "MiddleName": "",
      "NiNumber": ""
    },
    "FirstName": "",
    "Gender": "",
    "HoursPerWeek": "",
    "Initials": "",
    "IrregularEmployment": false,
    "IsAgencyWorker": false,
    "LastName": "",
    "LeaverReason": "",
    "LeavingDate": "",
    "MaritalStatus": "",
    "MetaData": {},
    "MiddleName": "",
    "NextRevisionDate": "",
    "NiNumber": "",
    "NicLiability": "",
    "OffPayrollWorker": false,
    "OnStrike": false,
    "P45IssuedDate": "",
    "PassportNumber": "",
    "PaySchedule": {
      "@href": "",
      "@rel": "",
      "@title": ""
    },
    "PaymentMethod": "",
    "PaymentToANonIndividual": false,
    "Region": "",
    "Revision": 0,
    "RuleExclusions": "",
    "Seconded": "",
    "StartDate": "",
    "StarterDeclaration": "",
    "Territory": "",
    "Title": "",
    "VeteranPeriodStartDate": "",
    "WorkingWeek": ""
  }
}' |  \
  http POST {{baseUrl}}/Employer/:EmployerId/Employees \
  api-version:'' \
  authorization:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Employee": {\n    "AEAssessmentOverride": "",\n    "AEAssessmentOverrideDate": "",\n    "AEExclusionReasonCode": "",\n    "AEPostponementDate": "",\n    "Address": {\n      "Address1": "",\n      "Address2": "",\n      "Address3": "",\n      "Address4": "",\n      "Country": "",\n      "Postcode": ""\n    },\n    "BankAccount": {\n      "AccountName": "",\n      "AccountNumber": "",\n      "BranchName": "",\n      "Reference": "",\n      "SortCode": ""\n    },\n    "Code": "",\n    "DateOfBirth": "",\n    "Deactivated": false,\n    "DirectorshipAppointmentDate": "",\n    "EEACitizen": false,\n    "EPM6": false,\n    "EffectiveDate": "",\n    "EmployeePartner": {\n      "FirstName": "",\n      "Initials": "",\n      "LastName": "",\n      "MiddleName": "",\n      "NiNumber": ""\n    },\n    "FirstName": "",\n    "Gender": "",\n    "HoursPerWeek": "",\n    "Initials": "",\n    "IrregularEmployment": false,\n    "IsAgencyWorker": false,\n    "LastName": "",\n    "LeaverReason": "",\n    "LeavingDate": "",\n    "MaritalStatus": "",\n    "MetaData": {},\n    "MiddleName": "",\n    "NextRevisionDate": "",\n    "NiNumber": "",\n    "NicLiability": "",\n    "OffPayrollWorker": false,\n    "OnStrike": false,\n    "P45IssuedDate": "",\n    "PassportNumber": "",\n    "PaySchedule": {\n      "@href": "",\n      "@rel": "",\n      "@title": ""\n    },\n    "PaymentMethod": "",\n    "PaymentToANonIndividual": false,\n    "Region": "",\n    "Revision": 0,\n    "RuleExclusions": "",\n    "Seconded": "",\n    "StartDate": "",\n    "StarterDeclaration": "",\n    "Territory": "",\n    "Title": "",\n    "VeteranPeriodStartDate": "",\n    "WorkingWeek": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employees

import Foundation

let headers = [
  "authorization": "",
  "api-version": "",
  "content-type": "application/json"
]
let parameters = ["Employee": [
    "AEAssessmentOverride": "",
    "AEAssessmentOverrideDate": "",
    "AEExclusionReasonCode": "",
    "AEPostponementDate": "",
    "Address": [
      "Address1": "",
      "Address2": "",
      "Address3": "",
      "Address4": "",
      "Country": "",
      "Postcode": ""
    ],
    "BankAccount": [
      "AccountName": "",
      "AccountNumber": "",
      "BranchName": "",
      "Reference": "",
      "SortCode": ""
    ],
    "Code": "",
    "DateOfBirth": "",
    "Deactivated": false,
    "DirectorshipAppointmentDate": "",
    "EEACitizen": false,
    "EPM6": false,
    "EffectiveDate": "",
    "EmployeePartner": [
      "FirstName": "",
      "Initials": "",
      "LastName": "",
      "MiddleName": "",
      "NiNumber": ""
    ],
    "FirstName": "",
    "Gender": "",
    "HoursPerWeek": "",
    "Initials": "",
    "IrregularEmployment": false,
    "IsAgencyWorker": false,
    "LastName": "",
    "LeaverReason": "",
    "LeavingDate": "",
    "MaritalStatus": "",
    "MetaData": [],
    "MiddleName": "",
    "NextRevisionDate": "",
    "NiNumber": "",
    "NicLiability": "",
    "OffPayrollWorker": false,
    "OnStrike": false,
    "P45IssuedDate": "",
    "PassportNumber": "",
    "PaySchedule": [
      "@href": "",
      "@rel": "",
      "@title": ""
    ],
    "PaymentMethod": "",
    "PaymentToANonIndividual": false,
    "Region": "",
    "Revision": 0,
    "RuleExclusions": "",
    "Seconded": "",
    "StartDate": "",
    "StarterDeclaration": "",
    "Territory": "",
    "Title": "",
    "VeteranPeriodStartDate": "",
    "WorkingWeek": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employees")! 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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets" {:headers {:authorization ""
                                                                                                        :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secrets HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets")
  .post(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets';
const options = {method: 'POST', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets',
  method: 'POST',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets")
  .post(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secrets',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets';
const options = {method: 'POST', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets');
$request->setRequestMethod('POST');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets' -Method POST -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("POST", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secrets", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"

response <- VERB("POST", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secrets') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets \
  api-version:'' \
  authorization:''

wget --quiet \
  --method POST \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId" {:headers {:authorization ""
                                                                                                                :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"))
    .header("authorization", "")
    .header("api-version", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")
  .put(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")
  .header("authorization", "")
  .header("api-version", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId';
const options = {method: 'PUT', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  method: 'PUT',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")
  .put(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId');

req.headers({
  authorization: '',
  'api-version': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId';
const options = {method: 'PUT', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId' -Method PUT -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("PUT", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.put(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"

response <- VERB("PUT", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http PUT {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method PUT \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate" {:headers {:authorization ""
                                                                                                                 :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate',
  method: 'DELETE',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("DELETE", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"

response <- VERB("DELETE", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate \
  api-version:'' \
  authorization:''

wget --quiet \
  --method DELETE \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber" {:headers {:authorization ""
                                                                                                                           :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber',
  method: 'DELETE',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("DELETE", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber"

response <- VERB("DELETE", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber \
  api-version:'' \
  authorization:''

wget --quiet \
  --method DELETE \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revision/:RevisionNumber")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId" {:headers {:authorization ""
                                                                                                  :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/Employer/:EmployerId/Employee/:EmployeeId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId',
  method: 'DELETE',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("DELETE", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId"

response <- VERB("DELETE", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method DELETE \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId" {:headers {:authorization ""
                                                                                                                   :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  method: 'DELETE',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")
  .delete(null)
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId';
const options = {method: 'DELETE', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("DELETE", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"

response <- VERB("DELETE", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method DELETE \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")! 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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary" {:headers {:authorization ""
                                                                                                                 :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions/Summary")! 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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions" {:headers {:authorization ""
                                                                                                         :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Revisions HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Revisions',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Revisions", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Revisions') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Revisions")! 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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets" {:headers {:authorization ""
                                                                                                       :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secrets HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secrets',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secrets", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secrets') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secrets")! 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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees" {:headers {:authorization ""
                                                                                                               :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees"]
                                                       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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/Employees")! 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}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId" {:headers {:authorization ""
                                                                                                                        :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Commentary/:CommentaryId")! 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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary" {:headers {:authorization ""
                                                                                                                                                      :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary"]
                                                       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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/PaySchedule/:PayScheduleId/PayRun/:PayRunId/Employee/:EmployeeId/Commentary")! 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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate" {:headers {:authorization ""
                                                                                                              :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/:EffectiveDate")! 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}}/Employer/:EmployerId/Employee/:EmployeeId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId" {:headers {:authorization ""
                                                                                               :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/Employer/:EmployerId/Employee/:EmployeeId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId")! 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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId" {:headers {:authorization ""
                                                                                                                :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"]
                                                       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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "")
$headers.Add("api-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'authorization': "",
    'api-version': ""
}

conn.request("GET", "/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"

headers = {
    "authorization": "",
    "api-version": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId"

response <- VERB("GET", url, add_headers('authorization' = '', 'api-version' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["api-version"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId') do |req|
  req.headers['authorization'] = ''
  req.headers['api-version'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "".parse().unwrap());
    headers.insert("api-version", "".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}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId \
  api-version:'' \
  authorization:''

wget --quiet \
  --method GET \
  --header 'authorization: ' \
  --header 'api-version: ' \
  --output-document \
  - {{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId

import Foundation

let headers = [
  "authorization": "",
  "api-version": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/Employer/:EmployerId/Employee/:EmployeeId/Secret/:SecretId")! 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}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "api-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary" {:headers {:authorization ""
                                                                                                           :api-version ""}})

require "http/client"

url = "{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary"
headers = HTTP::Headers{
  "authorization" => ""
  "api-version" => ""
}

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}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary"),
    Headers =
    {
        { "authorization", "" },
        { "api-version", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("api-version", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("authorization", "")
	req.Header.Add("api-version", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/Employer/:EmployerId/Employees/:EffectiveDate/Summary HTTP/1.1
Authorization: 
Api-Version: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary")
  .setHeader("authorization", "")
  .setHeader("api-version", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary"))
    .header("authorization", "")
    .header("api-version", "")
    .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}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary")
  .header("authorization", "")
  .header("api-version", "")
  .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}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('api-version', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary',
  method: 'GET',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary")
  .get()
  .addHeader("authorization", "")
  .addHeader("api-version", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/Employer/:EmployerId/Employees/:EffectiveDate/Summary',
  headers: {
    authorization: '',
    'api-version': ''
  }
};

const req = http.request(options, function (res) {
  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}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary',
  headers: {authorization: '', 'api-version': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary');

req.headers({
  authorization: '',
  'api-version': ''
});

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}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary',
  headers: {authorization: '', 'api-version': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary';
const options = {method: 'GET', headers: {authorization: '', 'api-version': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"authorization": @"",
                           @"api-version": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary"]
                                                       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}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "");
  ("api-version", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "api-version: ",
    "authorization: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary', [
  'headers' => [
    'api-version' => '',
    'authorization' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/Employer/:EmployerId/Employees/:EffectiveDate/Summary');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '',
  'api-version' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();