LetMC Api V2, Free (Tier 1)

GET A collection of all the areas for a company

{{baseUrl}}/v2/tier1/:shortName/area/areas

QUERY PARAMS

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/area/areas" {:query-params {:offset ""
                                                                                         :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count="

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/area/areas?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count="))
    .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}}/v2/tier1/:shortName/area/areas?offset=&count=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=")
  .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}}/v2/tier1/:shortName/area/areas?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/area/areas',
  params: {offset: '', count: ''}
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/area/areas?offset=&count=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/area/areas',
  qs: {offset: '', count: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/area/areas');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/area/areas',
  params: {offset: '', count: ''}
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=" in

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

 "{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/area/areas');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/area/areas');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/area/areas?offset=&count=")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/area/areas"

querystring = {"offset":"","count":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/area/areas"

queryString <- list(
  offset = "",
  count = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/area/areas') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/area/areas";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/area/areas?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Get a specific area given its unique Object ID (OID)

{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID

QUERY PARAMS

shortName

areaID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID"

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/area/areas/:areaID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID"))
    .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}}/v2/tier1/:shortName/area/areas/:areaID")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID")
  .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}}/v2/tier1/:shortName/area/areas/:areaID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID'
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/area/areas/:areaID',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID');

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}}/v2/tier1/:shortName/area/areas/:areaID'
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID" in

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

 "{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/area/areas/:areaID")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/area/areas/:areaID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID

http GET {{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/area/areas/:areaID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET All branches defined for a company

{{baseUrl}}/v2/tier1/:shortName/branch/branches

QUERY PARAMS

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/branch/branches" {:query-params {:offset ""
                                                                                              :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count="

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/branch/branches?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count="))
    .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}}/v2/tier1/:shortName/branch/branches?offset=&count=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=")
  .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}}/v2/tier1/:shortName/branch/branches?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/branch/branches',
  params: {offset: '', count: ''}
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/branch/branches?offset=&count=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/branch/branches',
  qs: {offset: '', count: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/branch/branches');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/branch/branches',
  params: {offset: '', count: ''}
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=" in

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

 "{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/branch/branches');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/branch/branches');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/branch/branches?offset=&count=")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/branch/branches"

querystring = {"offset":"","count":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/branch/branches"

queryString <- list(
  offset = "",
  count = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/branch/branches') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/branch/branches";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/branch/branches?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Get a specific branch given its unique Object ID (OID)

{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID

QUERY PARAMS

shortName

branchID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID"

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/branch/branches/:branchID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID"))
    .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}}/v2/tier1/:shortName/branch/branches/:branchID")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID")
  .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}}/v2/tier1/:shortName/branch/branches/:branchID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID'
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/branch/branches/:branchID',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID');

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}}/v2/tier1/:shortName/branch/branches/:branchID'
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID" in

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

 "{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/branch/branches/:branchID")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/branch/branches/:branchID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID

http GET {{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/branch/branches/:branchID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Information about a specific company

{{baseUrl}}/v2/tier1/:shortName/company

QUERY PARAMS

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/company");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/company")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/company"

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

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

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/company");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/company"

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/company HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/company")
  .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}}/v2/tier1/:shortName/company');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/tier1/:shortName/company'};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/company';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/company',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/company")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/company',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v2/tier1/:shortName/company'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/company');

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}}/v2/tier1/:shortName/company'};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/company';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/company"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/company" in

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

 "{{baseUrl}}/v2/tier1/:shortName/company",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/company');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/company');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/company');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/company' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/company' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/company")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/company"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/company"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/company")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/company') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/company

http GET {{baseUrl}}/v2/tier1/:shortName/company

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/company

import Foundation

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

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

dataTask.resume()

GET A collection of all counties available for a company

{{baseUrl}}/v2/tier1/:shortName/county/counties

QUERY PARAMS

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/county/counties" {:query-params {:offset ""
                                                                                              :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count="

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/county/counties?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count="))
    .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}}/v2/tier1/:shortName/county/counties?offset=&count=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=")
  .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}}/v2/tier1/:shortName/county/counties?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/county/counties',
  params: {offset: '', count: ''}
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/county/counties?offset=&count=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/county/counties',
  qs: {offset: '', count: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/county/counties');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/county/counties',
  params: {offset: '', count: ''}
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=" in

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

 "{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/county/counties');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/county/counties');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/county/counties?offset=&count=")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/county/counties"

querystring = {"offset":"","count":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/county/counties"

queryString <- list(
  offset = "",
  count = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/county/counties') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/county/counties";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/county/counties?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET A collection of branches that manage a specific county

{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches

QUERY PARAMS

offset

count

shortName

countyID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches" {:query-params {:offset ""
                                                                                                                 :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count="

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count="))
    .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}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=")
  .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}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches',
  params: {offset: '', count: ''}
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches',
  qs: {offset: '', count: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/county/counties/:countyID/branches',
  params: {offset: '', count: ''}
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=" in

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

 "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches"

querystring = {"offset":"","count":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches"

queryString <- list(
  offset = "",
  count = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/county/counties/:countyID/branches') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID/branches?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Get a specific county given its unique Object ID (OID)

{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID

QUERY PARAMS

shortName

countyID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID"

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/county/counties/:countyID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID"))
    .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}}/v2/tier1/:shortName/county/counties/:countyID")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID")
  .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}}/v2/tier1/:shortName/county/counties/:countyID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID'
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/county/counties/:countyID',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID');

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}}/v2/tier1/:shortName/county/counties/:countyID'
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID" in

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

 "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/county/counties/:countyID")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/county/counties/:countyID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID

http GET {{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/county/counties/:countyID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET A collection of all diary allocations

{{baseUrl}}/v2/tier1/:shortName/diary/allocations

QUERY PARAMS

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/diary/allocations" {:query-params {:offset ""
                                                                                                :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count="

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/diary/allocations?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count="))
    .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}}/v2/tier1/:shortName/diary/allocations?offset=&count=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=")
  .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}}/v2/tier1/:shortName/diary/allocations?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/allocations',
  params: {offset: '', count: ''}
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/diary/allocations?offset=&count=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/allocations',
  qs: {offset: '', count: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/diary/allocations');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/diary/allocations',
  params: {offset: '', count: ''}
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=" in

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

 "{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/diary/allocations');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/diary/allocations');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/diary/allocations?offset=&count=")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/diary/allocations"

querystring = {"offset":"","count":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/diary/allocations"

queryString <- list(
  offset = "",
  count = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/diary/allocations') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/diary/allocations";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/diary/allocations?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET A collection of all diary appointment types

{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes

QUERY PARAMS

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes" {:query-params {:offset ""
                                                                                                     :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count="

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/diary/appointmenttypes?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count="))
    .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}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=")
  .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}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes',
  params: {offset: '', count: ''}
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes',
  qs: {offset: '', count: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/diary/appointmenttypes',
  params: {offset: '', count: ''}
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=" in

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

 "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes"

querystring = {"offset":"","count":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes"

queryString <- list(
  offset = "",
  count = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/diary/appointmenttypes') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET A collection of all diary appointments

{{baseUrl}}/v2/tier1/:shortName/diary/appointments

QUERY PARAMS

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/diary/appointments" {:query-params {:offset ""
                                                                                                 :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count="

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/diary/appointments?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count="))
    .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}}/v2/tier1/:shortName/diary/appointments?offset=&count=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=")
  .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}}/v2/tier1/:shortName/diary/appointments?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/appointments',
  params: {offset: '', count: ''}
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/diary/appointments?offset=&count=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/appointments',
  qs: {offset: '', count: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/diary/appointments');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/diary/appointments',
  params: {offset: '', count: ''}
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=" in

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

 "{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/diary/appointments');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/diary/appointments');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/diary/appointments?offset=&count=")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/diary/appointments"

querystring = {"offset":"","count":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/diary/appointments"

queryString <- list(
  offset = "",
  count = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/diary/appointments') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/diary/appointments";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/diary/appointments?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Get a specific diary allocation given its unique Object ID (OID)

{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID

QUERY PARAMS

shortName

diaryAllocationID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID"

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/diary/allocations/:diaryAllocationID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID"))
    .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}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID")
  .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}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID'
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/diary/allocations/:diaryAllocationID',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID');

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}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID'
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID" in

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

 "{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/diary/allocations/:diaryAllocationID")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/diary/allocations/:diaryAllocationID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID

http GET {{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/diary/allocations/:diaryAllocationID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Get a specific diary appointment given its unique Object ID (OID)

{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID

QUERY PARAMS

shortName

diaryAppointmentID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID"

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID"))
    .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}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID")
  .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}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID'
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID');

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}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID'
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID" in

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

 "{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID

http GET {{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/diary/appointments/:diaryAppointmentID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Get a specific diary appointment type given its unique Object ID (OID)

{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID

QUERY PARAMS

shortName

diaryAppointmentTypeID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID"

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID"))
    .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}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID")
  .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}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID'
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID');

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}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID'
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID" in

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

 "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID

http GET {{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/diary/appointmenttypes/:diaryAppointmentTypeID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET A collection of all the company's tenancies

{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies

QUERY PARAMS

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies" {:query-params {:offset ""
                                                                                                 :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count="

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/lettings/tenancies?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count="))
    .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}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=")
  .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}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies',
  params: {offset: '', count: ''}
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/lettings/tenancies?offset=&count=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies',
  qs: {offset: '', count: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/lettings/tenancies',
  params: {offset: '', count: ''}
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=" in

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

 "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/lettings/tenancies?offset=&count=")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies"

querystring = {"offset":"","count":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies"

queryString <- list(
  offset = "",
  count = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/lettings/tenancies') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Downloads the brochure relating to the latest advertised rental of a property

{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure

QUERY PARAMS

shortName

tenancyID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure"

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure"))
    .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}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure")
  .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}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure'
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure');

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}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure'
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure" in

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

 "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure

http GET {{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID/brochure")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Get a specific tenancy given its unique Object ID (OID)

{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID

QUERY PARAMS

shortName

tenancyID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID"

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/lettings/tenancies/:tenancyID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID"))
    .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}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID")
  .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}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID'
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/lettings/tenancies/:tenancyID',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID');

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}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID'
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID" in

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

 "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/lettings/tenancies/:tenancyID")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/lettings/tenancies/:tenancyID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID

http GET {{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/lettings/tenancies/:tenancyID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Search all properties available for rent given a range of search criteria and dates.

{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates

QUERY PARAMS

branchID

offset

count

rangeStartDate

rangeEndDate

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates" {:query-params {:branchID ""
                                                                                                              :offset ""
                                                                                                              :count ""
                                                                                                              :rangeStartDate ""
                                                                                                              :rangeEndDate ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate="

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate="))
    .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}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=")
  .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}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates',
  params: {branchID: '', offset: '', count: '', rangeStartDate: '', rangeEndDate: ''}
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates',
  qs: {branchID: '', offset: '', count: '', rangeStartDate: '', rangeEndDate: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates');

req.query({
  branchID: '',
  offset: '',
  count: '',
  rangeStartDate: '',
  rangeEndDate: ''
});

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}}/v2/tier1/:shortName/lettings/advertisedbetweendates',
  params: {branchID: '', offset: '', count: '', rangeStartDate: '', rangeEndDate: ''}
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=" in

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

 "{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'branchID' => '',
  'offset' => '',
  'count' => '',
  'rangeStartDate' => '',
  'rangeEndDate' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'branchID' => '',
  'offset' => '',
  'count' => '',
  'rangeStartDate' => '',
  'rangeEndDate' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates"

querystring = {"branchID":"","offset":"","count":"","rangeStartDate":"","rangeEndDate":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates"

queryString <- list(
  branchID = "",
  offset = "",
  count = "",
  rangeStartDate = "",
  rangeEndDate = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/lettings/advertisedbetweendates') do |req|
  req.params['branchID'] = ''
  req.params['offset'] = ''
  req.params['count'] = ''
  req.params['rangeStartDate'] = ''
  req.params['rangeEndDate'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates";

    let querystring = [
        ("branchID", ""),
        ("offset", ""),
        ("count", ""),
        ("rangeStartDate", ""),
        ("rangeEndDate", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate='

http GET '{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/lettings/advertisedbetweendates?branchID=&offset=&count=&rangeStartDate=&rangeEndDate=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Search all properties available for rent given a range of search criteria.

{{baseUrl}}/v2/tier1/:shortName/lettings/advertised

QUERY PARAMS

branchID

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/lettings/advertised" {:query-params {:branchID ""
                                                                                                  :offset ""
                                                                                                  :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count="

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count="))
    .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}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=")
  .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}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/advertised',
  params: {branchID: '', offset: '', count: ''}
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/lettings/advertised',
  qs: {branchID: '', offset: '', count: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/lettings/advertised');

req.query({
  branchID: '',
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/lettings/advertised',
  params: {branchID: '', offset: '', count: ''}
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=" in

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

 "{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/lettings/advertised');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'branchID' => '',
  'offset' => '',
  'count' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/lettings/advertised');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'branchID' => '',
  'offset' => '',
  'count' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/lettings/advertised"

querystring = {"branchID":"","offset":"","count":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/lettings/advertised"

queryString <- list(
  branchID = "",
  offset = "",
  count = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/lettings/advertised') do |req|
  req.params['branchID'] = ''
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/lettings/advertised";

    let querystring = [
        ("branchID", ""),
        ("offset", ""),
        ("count", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/lettings/advertised?branchID=&offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET A collection of all photos in the company

{{baseUrl}}/v2/tier1/:shortName/photo/photos

QUERY PARAMS

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/photo/photos" {:query-params {:offset ""
                                                                                           :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count="

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/photo/photos?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count="))
    .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}}/v2/tier1/:shortName/photo/photos?offset=&count=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=")
  .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}}/v2/tier1/:shortName/photo/photos?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/photo/photos',
  params: {offset: '', count: ''}
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/photo/photos?offset=&count=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/photo/photos',
  qs: {offset: '', count: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/photo/photos');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/photo/photos',
  params: {offset: '', count: ''}
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=" in

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

 "{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/photo/photos');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/photo/photos');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/photo/photos?offset=&count=")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/photo/photos"

querystring = {"offset":"","count":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/photo/photos"

queryString <- list(
  offset = "",
  count = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/photo/photos') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/photo/photos";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/photo/photos?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Downloads the photo of a property given the property and photo ID.

{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download

QUERY PARAMS

shortName

photoID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download"

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/photos/photo/:photoID/download HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download"))
    .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}}/v2/tier1/:shortName/photos/photo/:photoID/download")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download")
  .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}}/v2/tier1/:shortName/photos/photo/:photoID/download');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download'
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/photos/photo/:photoID/download',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download');

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}}/v2/tier1/:shortName/photos/photo/:photoID/download'
};

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

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

const url = '{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download" in

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

 "{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v2/tier1/:shortName/photos/photo/:photoID/download")

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

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

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v2/tier1/:shortName/photos/photo/:photoID/download') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download

http GET {{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/photos/photo/:photoID/download")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET Get a specific photo given its unique Object ID (OID)

{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID

QUERY PARAMS

shortName

photoID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID"

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

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

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

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

}

GET /baseUrl/v2/tier1/:shortName/photo/photos/:photoID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID"))
    .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}}/v2/tier1/:shortName/photo/photos/:photoID")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID")
  .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}}/v2/tier1/:shortName/photo/photos/:photoID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID'
};

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

const url = '{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/photo/photos/:photoID',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID');

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}}/v2/tier1/:shortName/photo/photos/:photoID'
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/photo/photos/:photoID")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/photo/photos/:photoID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID

http GET {{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/photo/photos/:photoID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A collection of all properties within a company

{{baseUrl}}/v2/tier1/:shortName/property/properties

QUERY PARAMS

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/property/properties" {:query-params {:offset ""
                                                                                                  :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/property/properties?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count="))
    .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}}/v2/tier1/:shortName/property/properties?offset=&count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=")
  .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}}/v2/tier1/:shortName/property/properties?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/property/properties?offset=&count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties',
  qs: {offset: '', count: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/property/properties');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/property/properties',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/property/properties');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/property/properties');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/property/properties?offset=&count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/property/properties"

querystring = {"offset":"","count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/property/properties"

queryString <- list(
  offset = "",
  count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/property/properties') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/property/properties";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/property/properties?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A collection of all tenancies associated with this block, property or room

{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies

QUERY PARAMS

offset

count

shortName

propertyID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies" {:query-params {:offset ""
                                                                                                                        :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count="))
    .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}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=")
  .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}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies',
  qs: {offset: '', count: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies"

querystring = {"offset":"","count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies"

queryString <- list(
  offset = "",
  count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/property/properties/:propertyID/tenancies') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/tenancies?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A collection of facilities linked to a block, property or room

{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities

QUERY PARAMS

offset

count

shortName

propertyID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities" {:query-params {:offset ""
                                                                                                                         :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count="))
    .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}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=")
  .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}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities',
  qs: {offset: '', count: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/property/properties/:propertyID/facilities',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities"

querystring = {"offset":"","count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities"

queryString <- list(
  offset = "",
  count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/property/properties/:propertyID/facilities') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/facilities?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A collection of the rooms that belong to this property or block

{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms

QUERY PARAMS

offset

count

shortName

propertyID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms" {:query-params {:offset ""
                                                                                                                    :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count="))
    .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}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=")
  .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}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms',
  qs: {offset: '', count: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/property/properties/:propertyID/rooms',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms"

querystring = {"offset":"","count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms"

queryString <- list(
  offset = "",
  count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/property/properties/:propertyID/rooms') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/rooms?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A collection showing all the photos linked to a specific block, property or room

{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos

QUERY PARAMS

offset

count

shortName

propertyID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos" {:query-params {:offset ""
                                                                                                                     :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count="))
    .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}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=")
  .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}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos',
  qs: {offset: '', count: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/property/properties/:propertyID/photos',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos"

querystring = {"offset":"","count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos"

queryString <- list(
  offset = "",
  count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/property/properties/:propertyID/photos') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID/photos?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Downloads the energy efficiency report (EER) graph for a property

{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer

QUERY PARAMS

shortName

propertyStructureID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer"))
    .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}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer")
  .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}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer');

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}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer

http GET {{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eer")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Downloads the environmental impact report (EIR) graph for a property

{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir

QUERY PARAMS

shortName

propertyStructureID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir"))
    .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}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir")
  .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}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir');

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}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir

http GET {{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/property/structures/:propertyStructureID/reports/eir")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get a specific property given its unique Object ID (OID)

{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID

QUERY PARAMS

shortName

propertyID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/property/properties/:propertyID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID"))
    .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}}/v2/tier1/:shortName/property/properties/:propertyID")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID")
  .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}}/v2/tier1/:shortName/property/properties/:propertyID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/property/properties/:propertyID',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID');

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}}/v2/tier1/:shortName/property/properties/:propertyID'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/property/properties/:propertyID")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/property/properties/:propertyID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID

http GET {{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/property/properties/:propertyID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A collection of all features linked to a sales instruction

{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features

QUERY PARAMS

offset

count

shortName

salesInstructionID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features" {:query-params {:offset ""
                                                                                                                                   :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count="))
    .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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=")
  .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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features',
  qs: {offset: '', count: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features"

querystring = {"offset":"","count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features"

queryString <- list(
  offset = "",
  count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/features?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A collection of all sales feature types linked to a company

{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes

QUERY PARAMS

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes" {:query-params {:offset ""
                                                                                                      :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count="))
    .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}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=")
  .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}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes',
  qs: {offset: '', count: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/sales/salesfeaturetypes',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes"

querystring = {"offset":"","count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes"

queryString <- list(
  offset = "",
  count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/sales/salesfeaturetypes') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A collection of all sales instructions linked to a company

{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions

QUERY PARAMS

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions" {:query-params {:offset ""
                                                                                                      :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/sales/salesinstructions?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count="))
    .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}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=")
  .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}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/sales/salesinstructions?offset=&count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions',
  qs: {offset: '', count: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/sales/salesinstructions',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/sales/salesinstructions?offset=&count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions"

querystring = {"offset":"","count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions"

queryString <- list(
  offset = "",
  count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/sales/salesinstructions') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A collection of floor plans linked to an instruction

{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans

QUERY PARAMS

offset

count

shortName

salesInstructionID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans" {:query-params {:offset ""
                                                                                                                                     :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count="))
    .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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=")
  .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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans',
  qs: {offset: '', count: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans"

querystring = {"offset":"","count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans"

queryString <- list(
  offset = "",
  count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/floorplans?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A collection of photos linked to an instruction

{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos

QUERY PARAMS

offset

count

shortName

salesInstructionID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos" {:query-params {:offset ""
                                                                                                                                 :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count="))
    .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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=")
  .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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos',
  qs: {offset: '', count: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos"

querystring = {"offset":"","count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos"

queryString <- list(
  offset = "",
  count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/photos?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A collection of rooms linked to an instruction

{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms

QUERY PARAMS

offset

count

shortName

salesInstructionID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms" {:query-params {:offset ""
                                                                                                                                :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count="))
    .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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=")
  .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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms',
  qs: {offset: '', count: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms"

querystring = {"offset":"","count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms"

queryString <- list(
  offset = "",
  count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID/rooms?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Downloads the energy efficiency report (EER) graph for a sales instruction

{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID

QUERY PARAMS

shortName

salesInstructionID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID"))
    .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}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID")
  .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}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID');

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}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID

http GET {{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eer/:salesInstructionID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Downloads the energy efficiency report (EIR) graph for a sales instruction

{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID

QUERY PARAMS

shortName

salesInstructionID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID"))
    .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}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID")
  .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}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID');

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}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID

http GET {{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/sales/reports/eir/:salesInstructionID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get a specific sales feature type given its unique Object ID (OID)

{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID

QUERY PARAMS

shortName

salesFeatureTypeID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID"))
    .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}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID")
  .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}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID');

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}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID

http GET {{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/sales/salesfeaturetypes/:salesFeatureTypeID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get a specific sales instruction given its unique Object ID (OID)

{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID

QUERY PARAMS

shortName

salesInstructionID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID"))
    .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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID")
  .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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID');

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}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID

http GET {{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/sales/salesinstructions/:salesInstructionID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Search all sales properties available given a range of search criteria

{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales

QUERY PARAMS

branchID

offset

count

onlyDevelopement

onlyInvestements

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales" {:query-params {:branchID ""
                                                                                                    :offset ""
                                                                                                    :count ""
                                                                                                    :onlyDevelopement ""
                                                                                                    :onlyInvestements ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements="))
    .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}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=")
  .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}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales',
  params: {
    branchID: '',
    offset: '',
    count: '',
    onlyDevelopement: '',
    onlyInvestements: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales',
  qs: {
    branchID: '',
    offset: '',
    count: '',
    onlyDevelopement: '',
    onlyInvestements: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales');

req.query({
  branchID: '',
  offset: '',
  count: '',
  onlyDevelopement: '',
  onlyInvestements: ''
});

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}}/v2/tier1/:shortName/sales/advertisedsales',
  params: {
    branchID: '',
    offset: '',
    count: '',
    onlyDevelopement: '',
    onlyInvestements: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'branchID' => '',
  'offset' => '',
  'count' => '',
  'onlyDevelopement' => '',
  'onlyInvestements' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'branchID' => '',
  'offset' => '',
  'count' => '',
  'onlyDevelopement' => '',
  'onlyInvestements' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales"

querystring = {"branchID":"","offset":"","count":"","onlyDevelopement":"","onlyInvestements":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales"

queryString <- list(
  branchID = "",
  offset = "",
  count = "",
  onlyDevelopement = "",
  onlyInvestements = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/sales/advertisedsales') do |req|
  req.params['branchID'] = ''
  req.params['offset'] = ''
  req.params['count'] = ''
  req.params['onlyDevelopement'] = ''
  req.params['onlyInvestements'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales";

    let querystring = [
        ("branchID", ""),
        ("offset", ""),
        ("count", ""),
        ("onlyDevelopement", ""),
        ("onlyInvestements", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements='

http GET '{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/sales/advertisedsales?branchID=&offset=&count=&onlyDevelopement=&onlyInvestements=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A collection of all the staff members linked to a specific company

{{baseUrl}}/v2/tier1/:shortName/staff/staff

QUERY PARAMS

offset

count

shortName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/staff/staff" {:query-params {:offset ""
                                                                                          :count ""}})

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/staff/staff?offset=&count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count="))
    .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}}/v2/tier1/:shortName/staff/staff?offset=&count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=")
  .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}}/v2/tier1/:shortName/staff/staff?offset=&count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/staff/staff',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/staff/staff?offset=&count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/staff/staff',
  qs: {offset: '', count: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/staff/staff');

req.query({
  offset: '',
  count: ''
});

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}}/v2/tier1/:shortName/staff/staff',
  params: {offset: '', count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/staff/staff');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'offset' => '',
  'count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/staff/staff');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'offset' => '',
  'count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/staff/staff?offset=&count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/staff/staff"

querystring = {"offset":"","count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/staff/staff"

queryString <- list(
  offset = "",
  count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/staff/staff') do |req|
  req.params['offset'] = ''
  req.params['count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/staff/staff";

    let querystring = [
        ("offset", ""),
        ("count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count='

http GET '{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/staff/staff?offset=&count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get a specific application staff given its unique Object ID (OID)

{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID

QUERY PARAMS

shortName

applicationStaffID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID")

require "http/client"

url = "{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/tier1/:shortName/staff/staff/:applicationStaffID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID"))
    .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}}/v2/tier1/:shortName/staff/staff/:applicationStaffID")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID")
  .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}}/v2/tier1/:shortName/staff/staff/:applicationStaffID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/tier1/:shortName/staff/staff/:applicationStaffID',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID');

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}}/v2/tier1/:shortName/staff/staff/:applicationStaffID'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/tier1/:shortName/staff/staff/:applicationStaffID")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/tier1/:shortName/staff/staff/:applicationStaffID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID

http GET {{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/tier1/:shortName/staff/staff/:applicationStaffID")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()