Books API

GET books.bookshelves.get

{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf

QUERY PARAMS

userId

shelf

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf")

require "http/client"

url = "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf"

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}}/books/v1/users/:userId/bookshelves/:shelf"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf"

	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/books/v1/users/:userId/bookshelves/:shelf HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf"))
    .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}}/books/v1/users/:userId/bookshelves/:shelf")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf")
  .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}}/books/v1/users/:userId/bookshelves/:shelf');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf'
};

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

const url = '{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf';
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}}/books/v1/users/:userId/bookshelves/:shelf',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf');

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}}/books/v1/users/:userId/bookshelves/:shelf'
};

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

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

const url = '{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf';
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}}/books/v1/users/:userId/bookshelves/:shelf"]
                                                       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}}/books/v1/users/:userId/bookshelves/:shelf" in

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

 "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf",
  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}}/books/v1/users/:userId/bookshelves/:shelf');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/users/:userId/bookshelves/:shelf")

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

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

import requests

url = "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf")

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/books/v1/users/:userId/bookshelves/:shelf') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf";

    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}}/books/v1/users/:userId/bookshelves/:shelf

http GET {{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf")! 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 books.bookshelves.list

{{baseUrl}}/books/v1/users/:userId/bookshelves

QUERY PARAMS

userId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/users/:userId/bookshelves");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/users/:userId/bookshelves")

require "http/client"

url = "{{baseUrl}}/books/v1/users/:userId/bookshelves"

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

var client = new RestClient("{{baseUrl}}/books/v1/users/:userId/bookshelves");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/users/:userId/bookshelves"

	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/books/v1/users/:userId/bookshelves HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/users/:userId/bookshelves"))
    .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}}/books/v1/users/:userId/bookshelves")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/users/:userId/bookshelves")
  .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}}/books/v1/users/:userId/bookshelves');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/users/:userId/bookshelves'
};

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

const url = '{{baseUrl}}/books/v1/users/:userId/bookshelves';
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}}/books/v1/users/:userId/bookshelves',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/users/:userId/bookshelves")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/users/:userId/bookshelves');

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}}/books/v1/users/:userId/bookshelves'
};

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

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

const url = '{{baseUrl}}/books/v1/users/:userId/bookshelves';
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}}/books/v1/users/:userId/bookshelves"]
                                                       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}}/books/v1/users/:userId/bookshelves" in

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

 "{{baseUrl}}/books/v1/users/:userId/bookshelves",
  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}}/books/v1/users/:userId/bookshelves');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/users/:userId/bookshelves');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/books/v1/users/:userId/bookshelves');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/users/:userId/bookshelves' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/users/:userId/bookshelves' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/users/:userId/bookshelves")

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

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

import requests

url = "{{baseUrl}}/books/v1/users/:userId/bookshelves"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/users/:userId/bookshelves"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/users/:userId/bookshelves")

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/books/v1/users/:userId/bookshelves') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/users/:userId/bookshelves";

    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}}/books/v1/users/:userId/bookshelves

http GET {{baseUrl}}/books/v1/users/:userId/bookshelves

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/users/:userId/bookshelves

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/users/:userId/bookshelves")! 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 books.bookshelves.volumes.list

{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes

QUERY PARAMS

userId

shelf

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes")

require "http/client"

url = "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes"

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}}/books/v1/users/:userId/bookshelves/:shelf/volumes"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes"

	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/books/v1/users/:userId/bookshelves/:shelf/volumes HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes"))
    .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}}/books/v1/users/:userId/bookshelves/:shelf/volumes")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes")
  .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}}/books/v1/users/:userId/bookshelves/:shelf/volumes');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes'
};

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

const url = '{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes';
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}}/books/v1/users/:userId/bookshelves/:shelf/volumes',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/users/:userId/bookshelves/:shelf/volumes',
  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}}/books/v1/users/:userId/bookshelves/:shelf/volumes'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes');

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}}/books/v1/users/:userId/bookshelves/:shelf/volumes'
};

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

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

const url = '{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes';
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}}/books/v1/users/:userId/bookshelves/:shelf/volumes"]
                                                       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}}/books/v1/users/:userId/bookshelves/:shelf/volumes" in

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

 "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes",
  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}}/books/v1/users/:userId/bookshelves/:shelf/volumes');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/users/:userId/bookshelves/:shelf/volumes")

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

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

import requests

url = "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes")

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/books/v1/users/:userId/bookshelves/:shelf/volumes') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes";

    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}}/books/v1/users/:userId/bookshelves/:shelf/volumes

http GET {{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/users/:userId/bookshelves/:shelf/volumes")! 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()

POST books.cloudloading.addBook

{{baseUrl}}/books/v1/cloudloading/addBook

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/cloudloading/addBook");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/books/v1/cloudloading/addBook")

require "http/client"

url = "{{baseUrl}}/books/v1/cloudloading/addBook"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/cloudloading/addBook"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/cloudloading/addBook"

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

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

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

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

}

POST /baseUrl/books/v1/cloudloading/addBook HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/cloudloading/addBook"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/cloudloading/addBook")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/cloudloading/addBook")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/books/v1/cloudloading/addBook');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/cloudloading/addBook'
};

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

const url = '{{baseUrl}}/books/v1/cloudloading/addBook';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/cloudloading/addBook',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/cloudloading/addBook")
  .post(null)
  .build()

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/cloudloading/addBook'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/cloudloading/addBook');

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/cloudloading/addBook'
};

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

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

const url = '{{baseUrl}}/books/v1/cloudloading/addBook';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/cloudloading/addBook"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/cloudloading/addBook" in

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

 "{{baseUrl}}/books/v1/cloudloading/addBook",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/books/v1/cloudloading/addBook');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/cloudloading/addBook');
$request->setMethod(HTTP_METH_POST);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/cloudloading/addBook' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/cloudloading/addBook' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/books/v1/cloudloading/addBook")

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

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

import requests

url = "{{baseUrl}}/books/v1/cloudloading/addBook"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/cloudloading/addBook"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/cloudloading/addBook")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/books/v1/cloudloading/addBook') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/books/v1/cloudloading/addBook

http POST {{baseUrl}}/books/v1/cloudloading/addBook

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/books/v1/cloudloading/addBook

import Foundation

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

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

dataTask.resume()

POST books.cloudloading.deleteBook

{{baseUrl}}/books/v1/cloudloading/deleteBook

QUERY PARAMS

volumeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/books/v1/cloudloading/deleteBook" {:query-params {:volumeId ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId="

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

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

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

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

}

POST /baseUrl/books/v1/cloudloading/deleteBook?volumeId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/cloudloading/deleteBook',
  params: {volumeId: ''}
};

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

const url = '{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/cloudloading/deleteBook?volumeId=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/cloudloading/deleteBook',
  qs: {volumeId: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/cloudloading/deleteBook');

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/cloudloading/deleteBook',
  params: {volumeId: ''}
};

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

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

const url = '{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=" in

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

 "{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/cloudloading/deleteBook');
$request->setMethod(HTTP_METH_POST);

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

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

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

setRequestUrl('{{baseUrl}}/books/v1/cloudloading/deleteBook');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'volumeId' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/books/v1/cloudloading/deleteBook?volumeId=")

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

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

import requests

url = "{{baseUrl}}/books/v1/cloudloading/deleteBook"

querystring = {"volumeId":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/cloudloading/deleteBook"

queryString <- list(volumeId = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/books/v1/cloudloading/deleteBook') do |req|
  req.params['volumeId'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId='

http POST '{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/cloudloading/deleteBook?volumeId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

POST books.cloudloading.updateBook

{{baseUrl}}/books/v1/cloudloading/updateBook

BODY json

{
  "author": "",
  "processingState": "",
  "title": "",
  "volumeId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/cloudloading/updateBook");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/books/v1/cloudloading/updateBook" {:content-type :json
                                                                             :form-params {:author ""
                                                                                           :processingState ""
                                                                                           :title ""
                                                                                           :volumeId ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/cloudloading/updateBook"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/cloudloading/updateBook"),
    Content = new StringContent("{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/cloudloading/updateBook");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/cloudloading/updateBook"

	payload := strings.NewReader("{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/books/v1/cloudloading/updateBook HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 76

{
  "author": "",
  "processingState": "",
  "title": "",
  "volumeId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/cloudloading/updateBook")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/cloudloading/updateBook"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/cloudloading/updateBook")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/cloudloading/updateBook")
  .header("content-type", "application/json")
  .body("{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  author: '',
  processingState: '',
  title: '',
  volumeId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/books/v1/cloudloading/updateBook');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/cloudloading/updateBook',
  headers: {'content-type': 'application/json'},
  data: {author: '', processingState: '', title: '', volumeId: ''}
};

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

const url = '{{baseUrl}}/books/v1/cloudloading/updateBook';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"author":"","processingState":"","title":"","volumeId":""}'
};

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}}/books/v1/cloudloading/updateBook',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "author": "",\n  "processingState": "",\n  "title": "",\n  "volumeId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/cloudloading/updateBook")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/cloudloading/updateBook',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({author: '', processingState: '', title: '', volumeId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/cloudloading/updateBook',
  headers: {'content-type': 'application/json'},
  body: {author: '', processingState: '', title: '', volumeId: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/cloudloading/updateBook');

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

req.type('json');
req.send({
  author: '',
  processingState: '',
  title: '',
  volumeId: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/cloudloading/updateBook',
  headers: {'content-type': 'application/json'},
  data: {author: '', processingState: '', title: '', volumeId: ''}
};

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

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

const url = '{{baseUrl}}/books/v1/cloudloading/updateBook';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"author":"","processingState":"","title":"","volumeId":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"author": @"",
                              @"processingState": @"",
                              @"title": @"",
                              @"volumeId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/cloudloading/updateBook"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/cloudloading/updateBook" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}" in

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

 "{{baseUrl}}/books/v1/cloudloading/updateBook",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'author' => '',
    'processingState' => '',
    'title' => '',
    'volumeId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/books/v1/cloudloading/updateBook', [
  'body' => '{
  "author": "",
  "processingState": "",
  "title": "",
  "volumeId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/cloudloading/updateBook');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'author' => '',
  'processingState' => '',
  'title' => '',
  'volumeId' => ''
]));

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

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

append(json_encode([
  'author' => '',
  'processingState' => '',
  'title' => '',
  'volumeId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/books/v1/cloudloading/updateBook');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/cloudloading/updateBook' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "author": "",
  "processingState": "",
  "title": "",
  "volumeId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/cloudloading/updateBook' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "author": "",
  "processingState": "",
  "title": "",
  "volumeId": ""
}'

import http.client

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

payload = "{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/books/v1/cloudloading/updateBook", payload, headers)

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

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

import requests

url = "{{baseUrl}}/books/v1/cloudloading/updateBook"

payload = {
    "author": "",
    "processingState": "",
    "title": "",
    "volumeId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/cloudloading/updateBook"

payload <- "{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/cloudloading/updateBook")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/books/v1/cloudloading/updateBook') do |req|
  req.body = "{\n  \"author\": \"\",\n  \"processingState\": \"\",\n  \"title\": \"\",\n  \"volumeId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "author": "",
        "processingState": "",
        "title": "",
        "volumeId": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/books/v1/cloudloading/updateBook \
  --header 'content-type: application/json' \
  --data '{
  "author": "",
  "processingState": "",
  "title": "",
  "volumeId": ""
}'

echo '{
  "author": "",
  "processingState": "",
  "title": "",
  "volumeId": ""
}' |  \
  http POST {{baseUrl}}/books/v1/cloudloading/updateBook \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "author": "",\n  "processingState": "",\n  "title": "",\n  "volumeId": ""\n}' \
  --output-document \
  - {{baseUrl}}/books/v1/cloudloading/updateBook

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "author": "",
  "processingState": "",
  "title": "",
  "volumeId": ""
] as [String : Any]

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

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

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

dataTask.resume()

GET books.dictionary.listOfflineMetadata

{{baseUrl}}/books/v1/dictionary/listOfflineMetadata

QUERY PARAMS

cpksver

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/dictionary/listOfflineMetadata" {:query-params {:cpksver ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver="

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

var client = new RestClient("{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver="

	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/books/v1/dictionary/listOfflineMetadata?cpksver= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver="))
    .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}}/books/v1/dictionary/listOfflineMetadata?cpksver=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver=")
  .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}}/books/v1/dictionary/listOfflineMetadata?cpksver=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/dictionary/listOfflineMetadata',
  params: {cpksver: ''}
};

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

const url = '{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver=';
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}}/books/v1/dictionary/listOfflineMetadata?cpksver=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/dictionary/listOfflineMetadata?cpksver=',
  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}}/books/v1/dictionary/listOfflineMetadata',
  qs: {cpksver: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/dictionary/listOfflineMetadata');

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

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}}/books/v1/dictionary/listOfflineMetadata',
  params: {cpksver: ''}
};

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

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

const url = '{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver=';
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}}/books/v1/dictionary/listOfflineMetadata?cpksver="]
                                                       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}}/books/v1/dictionary/listOfflineMetadata?cpksver=" in

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

 "{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver=",
  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}}/books/v1/dictionary/listOfflineMetadata?cpksver=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/dictionary/listOfflineMetadata');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/books/v1/dictionary/listOfflineMetadata');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'cpksver' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/dictionary/listOfflineMetadata?cpksver=")

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

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

import requests

url = "{{baseUrl}}/books/v1/dictionary/listOfflineMetadata"

querystring = {"cpksver":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/dictionary/listOfflineMetadata"

queryString <- list(cpksver = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver=")

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/books/v1/dictionary/listOfflineMetadata') do |req|
  req.params['cpksver'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

    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}}/books/v1/dictionary/listOfflineMetadata?cpksver='

http GET '{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/dictionary/listOfflineMetadata?cpksver=")! 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 books.familysharing.getFamilyInfo

{{baseUrl}}/books/v1/familysharing/getFamilyInfo

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/familysharing/getFamilyInfo");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/familysharing/getFamilyInfo")

require "http/client"

url = "{{baseUrl}}/books/v1/familysharing/getFamilyInfo"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/familysharing/getFamilyInfo"

	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/books/v1/familysharing/getFamilyInfo HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/familysharing/getFamilyInfo'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/familysharing/getFamilyInfo")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/familysharing/getFamilyInfo');

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}}/books/v1/familysharing/getFamilyInfo'
};

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

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

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

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

 "{{baseUrl}}/books/v1/familysharing/getFamilyInfo",
  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}}/books/v1/familysharing/getFamilyInfo');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/familysharing/getFamilyInfo');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/familysharing/getFamilyInfo' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/familysharing/getFamilyInfo' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/familysharing/getFamilyInfo")

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

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

import requests

url = "{{baseUrl}}/books/v1/familysharing/getFamilyInfo"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/familysharing/getFamilyInfo"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/familysharing/getFamilyInfo")

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/books/v1/familysharing/getFamilyInfo') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/books/v1/familysharing/getFamilyInfo

http GET {{baseUrl}}/books/v1/familysharing/getFamilyInfo

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/familysharing/getFamilyInfo

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/familysharing/getFamilyInfo")! 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()

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/familysharing/share");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/books/v1/familysharing/share")

require "http/client"

url = "{{baseUrl}}/books/v1/familysharing/share"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/familysharing/share"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/familysharing/share"

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

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

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

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

}

POST /baseUrl/books/v1/familysharing/share HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/familysharing/share"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/familysharing/share")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/familysharing/share")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/books/v1/familysharing/share');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/familysharing/share'
};

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

const url = '{{baseUrl}}/books/v1/familysharing/share';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/familysharing/share',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/familysharing/share")
  .post(null)
  .build()

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/familysharing/share'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/familysharing/share');

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/familysharing/share'
};

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

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

const url = '{{baseUrl}}/books/v1/familysharing/share';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/familysharing/share"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/familysharing/share" in

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

 "{{baseUrl}}/books/v1/familysharing/share",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/books/v1/familysharing/share');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/familysharing/share');
$request->setMethod(HTTP_METH_POST);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/familysharing/share' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/familysharing/share' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/books/v1/familysharing/share")

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

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

import requests

url = "{{baseUrl}}/books/v1/familysharing/share"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/familysharing/share"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/familysharing/share")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/books/v1/familysharing/share') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/books/v1/familysharing/share

http POST {{baseUrl}}/books/v1/familysharing/share

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/books/v1/familysharing/share

import Foundation

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

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

dataTask.resume()

POST books.familysharing.unshare

{{baseUrl}}/books/v1/familysharing/unshare

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/familysharing/unshare");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/books/v1/familysharing/unshare")

require "http/client"

url = "{{baseUrl}}/books/v1/familysharing/unshare"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/familysharing/unshare"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/familysharing/unshare"

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

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

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

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

}

POST /baseUrl/books/v1/familysharing/unshare HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/familysharing/unshare"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/familysharing/unshare")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/familysharing/unshare")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/books/v1/familysharing/unshare');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/familysharing/unshare'
};

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

const url = '{{baseUrl}}/books/v1/familysharing/unshare';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/familysharing/unshare',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/familysharing/unshare")
  .post(null)
  .build()

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/familysharing/unshare'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/familysharing/unshare');

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/familysharing/unshare'
};

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

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

const url = '{{baseUrl}}/books/v1/familysharing/unshare';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/familysharing/unshare"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/familysharing/unshare" in

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

 "{{baseUrl}}/books/v1/familysharing/unshare",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/books/v1/familysharing/unshare');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/familysharing/unshare');
$request->setMethod(HTTP_METH_POST);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/familysharing/unshare' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/familysharing/unshare' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/books/v1/familysharing/unshare")

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

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

import requests

url = "{{baseUrl}}/books/v1/familysharing/unshare"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/familysharing/unshare"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/familysharing/unshare")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/books/v1/familysharing/unshare') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/books/v1/familysharing/unshare

http POST {{baseUrl}}/books/v1/familysharing/unshare

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/books/v1/familysharing/unshare

import Foundation

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

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

dataTask.resume()

GET books.layers.annotationData.get

{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId

QUERY PARAMS

contentVersion

volumeId

layerId

annotationDataId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId" {:query-params {:contentVersion ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion="

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}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion="

	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/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion="))
    .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}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=")
  .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}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId',
  params: {contentVersion: ''}
};

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

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=';
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}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=',
  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}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId',
  qs: {contentVersion: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId');

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

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}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId',
  params: {contentVersion: ''}
};

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

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

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=';
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}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion="]
                                                       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}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=" in

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

 "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=",
  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}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'contentVersion' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=")

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

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

import requests

url = "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId"

querystring = {"contentVersion":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId"

queryString <- list(contentVersion = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=")

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/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId') do |req|
  req.params['contentVersion'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId";

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

    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}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion='

http GET '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data/:annotationDataId?contentVersion=")! 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 books.layers.annotationData.list

{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data

QUERY PARAMS

contentVersion

volumeId

layerId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data" {:query-params {:contentVersion ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion="

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}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion="

	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/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion="))
    .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}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=")
  .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}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data',
  params: {contentVersion: ''}
};

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

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=';
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}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=',
  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}}/books/v1/volumes/:volumeId/layers/:layerId/data',
  qs: {contentVersion: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data');

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

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}}/books/v1/volumes/:volumeId/layers/:layerId/data',
  params: {contentVersion: ''}
};

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

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

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=';
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}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion="]
                                                       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}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=" in

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

 "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=",
  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}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'contentVersion' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=")

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

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

import requests

url = "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data"

querystring = {"contentVersion":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data"

queryString <- list(contentVersion = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=")

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/books/v1/volumes/:volumeId/layers/:layerId/data') do |req|
  req.params['contentVersion'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data";

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

    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}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion='

http GET '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/data?contentVersion=")! 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 books.layers.get

{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId

QUERY PARAMS

volumeId

summaryId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId")

require "http/client"

url = "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId"

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}}/books/v1/volumes/:volumeId/layersummary/:summaryId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId"

	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/books/v1/volumes/:volumeId/layersummary/:summaryId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId"))
    .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}}/books/v1/volumes/:volumeId/layersummary/:summaryId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId")
  .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}}/books/v1/volumes/:volumeId/layersummary/:summaryId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId'
};

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

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId';
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}}/books/v1/volumes/:volumeId/layersummary/:summaryId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId');

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}}/books/v1/volumes/:volumeId/layersummary/:summaryId'
};

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

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

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId';
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}}/books/v1/volumes/:volumeId/layersummary/:summaryId"]
                                                       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}}/books/v1/volumes/:volumeId/layersummary/:summaryId" in

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

 "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId",
  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}}/books/v1/volumes/:volumeId/layersummary/:summaryId');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/volumes/:volumeId/layersummary/:summaryId")

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

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

import requests

url = "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId")

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/books/v1/volumes/:volumeId/layersummary/:summaryId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId";

    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}}/books/v1/volumes/:volumeId/layersummary/:summaryId

http GET {{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary/:summaryId")! 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 books.layers.list

{{baseUrl}}/books/v1/volumes/:volumeId/layersummary

QUERY PARAMS

volumeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary")

require "http/client"

url = "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary"

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

var client = new RestClient("{{baseUrl}}/books/v1/volumes/:volumeId/layersummary");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary"

	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/books/v1/volumes/:volumeId/layersummary HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes/:volumeId/layersummary"))
    .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}}/books/v1/volumes/:volumeId/layersummary")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/volumes/:volumeId/layersummary")
  .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}}/books/v1/volumes/:volumeId/layersummary');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/volumes/:volumeId/layersummary'
};

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

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/layersummary';
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}}/books/v1/volumes/:volumeId/layersummary',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/:volumeId/layersummary")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/volumes/:volumeId/layersummary');

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}}/books/v1/volumes/:volumeId/layersummary'
};

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

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

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/layersummary';
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}}/books/v1/volumes/:volumeId/layersummary"]
                                                       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}}/books/v1/volumes/:volumeId/layersummary" in

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

 "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary",
  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}}/books/v1/volumes/:volumeId/layersummary');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes/:volumeId/layersummary');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/books/v1/volumes/:volumeId/layersummary');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/layersummary' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/layersummary' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/volumes/:volumeId/layersummary")

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

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

import requests

url = "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes/:volumeId/layersummary")

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/books/v1/volumes/:volumeId/layersummary') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary";

    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}}/books/v1/volumes/:volumeId/layersummary

http GET {{baseUrl}}/books/v1/volumes/:volumeId/layersummary

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/volumes/:volumeId/layersummary

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes/:volumeId/layersummary")! 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 books.layers.volumeAnnotations.get

{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId

QUERY PARAMS

volumeId

layerId

annotationId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId")

require "http/client"

url = "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId"

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}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId"

	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/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId"))
    .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}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId")
  .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}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId'
};

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

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId';
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}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId',
  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}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId');

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}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId'
};

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

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

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId';
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}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId"]
                                                       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}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId" in

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

 "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId",
  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}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId")

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

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

import requests

url = "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId")

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/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId";

    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}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId

http GET {{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId/annotations/:annotationId")! 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 books.layers.volumeAnnotations.list

{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId

QUERY PARAMS

contentVersion

volumeId

layerId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId" {:query-params {:contentVersion ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion="

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}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion="

	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/books/v1/volumes/:volumeId/layers/:layerId?contentVersion= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion="))
    .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}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=")
  .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}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId',
  params: {contentVersion: ''}
};

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

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=';
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}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=',
  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}}/books/v1/volumes/:volumeId/layers/:layerId',
  qs: {contentVersion: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId');

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

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}}/books/v1/volumes/:volumeId/layers/:layerId',
  params: {contentVersion: ''}
};

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

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

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=';
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}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion="]
                                                       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}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=" in

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

 "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=",
  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}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'contentVersion' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=")

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

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

import requests

url = "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId"

querystring = {"contentVersion":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId"

queryString <- list(contentVersion = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=")

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/books/v1/volumes/:volumeId/layers/:layerId') do |req|
  req.params['contentVersion'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId";

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

    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}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion='

http GET '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes/:volumeId/layers/:layerId?contentVersion=")! 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 books.myconfig.getUserSettings

{{baseUrl}}/books/v1/myconfig/getUserSettings

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/myconfig/getUserSettings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/myconfig/getUserSettings")

require "http/client"

url = "{{baseUrl}}/books/v1/myconfig/getUserSettings"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/myconfig/getUserSettings"

	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/books/v1/myconfig/getUserSettings HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/myconfig/getUserSettings'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/myconfig/getUserSettings")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/myconfig/getUserSettings');

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}}/books/v1/myconfig/getUserSettings'
};

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

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

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

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

 "{{baseUrl}}/books/v1/myconfig/getUserSettings",
  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}}/books/v1/myconfig/getUserSettings');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/myconfig/getUserSettings');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/myconfig/getUserSettings' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/myconfig/getUserSettings' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/myconfig/getUserSettings")

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

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

import requests

url = "{{baseUrl}}/books/v1/myconfig/getUserSettings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/myconfig/getUserSettings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/myconfig/getUserSettings")

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/books/v1/myconfig/getUserSettings') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/books/v1/myconfig/getUserSettings

http GET {{baseUrl}}/books/v1/myconfig/getUserSettings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/myconfig/getUserSettings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/myconfig/getUserSettings")! 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()

POST books.myconfig.releaseDownloadAccess

{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess

QUERY PARAMS

cpksver

volumeIds

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess" {:query-params {:cpksver ""
                                                                                                   :volumeIds ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds="

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

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

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

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

}

POST /baseUrl/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess',
  params: {cpksver: '', volumeIds: ''}
};

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

const url = '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess',
  qs: {cpksver: '', volumeIds: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess');

req.query({
  cpksver: '',
  volumeIds: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess',
  params: {cpksver: '', volumeIds: ''}
};

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

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

const url = '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=" in

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

 "{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'cpksver' => '',
  'volumeIds' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'cpksver' => '',
  'volumeIds' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=")

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

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

import requests

url = "{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess"

querystring = {"cpksver":"","volumeIds":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess"

queryString <- list(
  cpksver = "",
  volumeIds = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/books/v1/myconfig/releaseDownloadAccess') do |req|
  req.params['cpksver'] = ''
  req.params['volumeIds'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("cpksver", ""),
        ("volumeIds", ""),
    ];

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds='

http POST '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/myconfig/releaseDownloadAccess?cpksver=&volumeIds=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

POST books.myconfig.requestAccess

{{baseUrl}}/books/v1/myconfig/requestAccess

QUERY PARAMS

cpksver

nonce

source

volumeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/books/v1/myconfig/requestAccess" {:query-params {:cpksver ""
                                                                                           :nonce ""
                                                                                           :source ""
                                                                                           :volumeId ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId="

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

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

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

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

}

POST /baseUrl/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/myconfig/requestAccess',
  params: {cpksver: '', nonce: '', source: '', volumeId: ''}
};

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

const url = '{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/myconfig/requestAccess',
  qs: {cpksver: '', nonce: '', source: '', volumeId: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/myconfig/requestAccess');

req.query({
  cpksver: '',
  nonce: '',
  source: '',
  volumeId: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/myconfig/requestAccess',
  params: {cpksver: '', nonce: '', source: '', volumeId: ''}
};

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

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

const url = '{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=" in

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

 "{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/myconfig/requestAccess');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'cpksver' => '',
  'nonce' => '',
  'source' => '',
  'volumeId' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/books/v1/myconfig/requestAccess');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'cpksver' => '',
  'nonce' => '',
  'source' => '',
  'volumeId' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=")

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

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

import requests

url = "{{baseUrl}}/books/v1/myconfig/requestAccess"

querystring = {"cpksver":"","nonce":"","source":"","volumeId":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/myconfig/requestAccess"

queryString <- list(
  cpksver = "",
  nonce = "",
  source = "",
  volumeId = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/books/v1/myconfig/requestAccess') do |req|
  req.params['cpksver'] = ''
  req.params['nonce'] = ''
  req.params['source'] = ''
  req.params['volumeId'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("cpksver", ""),
        ("nonce", ""),
        ("source", ""),
        ("volumeId", ""),
    ];

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId='

http POST '{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/myconfig/requestAccess?cpksver=&nonce=&source=&volumeId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

POST books.myconfig.syncVolumeLicenses

{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses

QUERY PARAMS

cpksver

nonce

source

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses" {:query-params {:cpksver ""
                                                                                                :nonce ""
                                                                                                :source ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source="

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

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

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

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

}

POST /baseUrl/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses',
  params: {cpksver: '', nonce: '', source: ''}
};

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

const url = '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses',
  qs: {cpksver: '', nonce: '', source: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses');

req.query({
  cpksver: '',
  nonce: '',
  source: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses',
  params: {cpksver: '', nonce: '', source: ''}
};

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

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

const url = '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=" in

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

 "{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'cpksver' => '',
  'nonce' => '',
  'source' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'cpksver' => '',
  'nonce' => '',
  'source' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=")

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

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

import requests

url = "{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses"

querystring = {"cpksver":"","nonce":"","source":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses"

queryString <- list(
  cpksver = "",
  nonce = "",
  source = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/books/v1/myconfig/syncVolumeLicenses') do |req|
  req.params['cpksver'] = ''
  req.params['nonce'] = ''
  req.params['source'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("cpksver", ""),
        ("nonce", ""),
        ("source", ""),
    ];

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source='

http POST '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/myconfig/syncVolumeLicenses?cpksver=&nonce=&source=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

POST books.myconfig.updateUserSettings

{{baseUrl}}/books/v1/myconfig/updateUserSettings

BODY json

{
  "kind": "",
  "notesExport": {
    "folderName": "",
    "isEnabled": false
  },
  "notification": {
    "matchMyInterests": {
      "opted_state": ""
    },
    "moreFromAuthors": {
      "opted_state": ""
    },
    "moreFromSeries": {
      "opted_state": ""
    },
    "priceDrop": {
      "opted_state": ""
    },
    "rewardExpirations": {
      "opted_state": ""
    }
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/myconfig/updateUserSettings");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/books/v1/myconfig/updateUserSettings" {:content-type :json
                                                                                 :form-params {:kind ""
                                                                                               :notesExport {:folderName ""
                                                                                                             :isEnabled false}
                                                                                               :notification {:matchMyInterests {:opted_state ""}
                                                                                                              :moreFromAuthors {:opted_state ""}
                                                                                                              :moreFromSeries {:opted_state ""}
                                                                                                              :priceDrop {:opted_state ""}
                                                                                                              :rewardExpirations {:opted_state ""}}}})

require "http/client"

url = "{{baseUrl}}/books/v1/myconfig/updateUserSettings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/myconfig/updateUserSettings"),
    Content = new StringContent("{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/myconfig/updateUserSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/myconfig/updateUserSettings"

	payload := strings.NewReader("{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}")

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

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

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

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

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

}

POST /baseUrl/books/v1/myconfig/updateUserSettings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 385

{
  "kind": "",
  "notesExport": {
    "folderName": "",
    "isEnabled": false
  },
  "notification": {
    "matchMyInterests": {
      "opted_state": ""
    },
    "moreFromAuthors": {
      "opted_state": ""
    },
    "moreFromSeries": {
      "opted_state": ""
    },
    "priceDrop": {
      "opted_state": ""
    },
    "rewardExpirations": {
      "opted_state": ""
    }
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/myconfig/updateUserSettings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/myconfig/updateUserSettings"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/myconfig/updateUserSettings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/myconfig/updateUserSettings")
  .header("content-type", "application/json")
  .body("{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}")
  .asString();

const data = JSON.stringify({
  kind: '',
  notesExport: {
    folderName: '',
    isEnabled: false
  },
  notification: {
    matchMyInterests: {
      opted_state: ''
    },
    moreFromAuthors: {
      opted_state: ''
    },
    moreFromSeries: {
      opted_state: ''
    },
    priceDrop: {
      opted_state: ''
    },
    rewardExpirations: {
      opted_state: ''
    }
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/books/v1/myconfig/updateUserSettings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/myconfig/updateUserSettings',
  headers: {'content-type': 'application/json'},
  data: {
    kind: '',
    notesExport: {folderName: '', isEnabled: false},
    notification: {
      matchMyInterests: {opted_state: ''},
      moreFromAuthors: {opted_state: ''},
      moreFromSeries: {opted_state: ''},
      priceDrop: {opted_state: ''},
      rewardExpirations: {opted_state: ''}
    }
  }
};

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

const url = '{{baseUrl}}/books/v1/myconfig/updateUserSettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"kind":"","notesExport":{"folderName":"","isEnabled":false},"notification":{"matchMyInterests":{"opted_state":""},"moreFromAuthors":{"opted_state":""},"moreFromSeries":{"opted_state":""},"priceDrop":{"opted_state":""},"rewardExpirations":{"opted_state":""}}}'
};

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}}/books/v1/myconfig/updateUserSettings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "kind": "",\n  "notesExport": {\n    "folderName": "",\n    "isEnabled": false\n  },\n  "notification": {\n    "matchMyInterests": {\n      "opted_state": ""\n    },\n    "moreFromAuthors": {\n      "opted_state": ""\n    },\n    "moreFromSeries": {\n      "opted_state": ""\n    },\n    "priceDrop": {\n      "opted_state": ""\n    },\n    "rewardExpirations": {\n      "opted_state": ""\n    }\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/myconfig/updateUserSettings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/myconfig/updateUserSettings',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  kind: '',
  notesExport: {folderName: '', isEnabled: false},
  notification: {
    matchMyInterests: {opted_state: ''},
    moreFromAuthors: {opted_state: ''},
    moreFromSeries: {opted_state: ''},
    priceDrop: {opted_state: ''},
    rewardExpirations: {opted_state: ''}
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/myconfig/updateUserSettings',
  headers: {'content-type': 'application/json'},
  body: {
    kind: '',
    notesExport: {folderName: '', isEnabled: false},
    notification: {
      matchMyInterests: {opted_state: ''},
      moreFromAuthors: {opted_state: ''},
      moreFromSeries: {opted_state: ''},
      priceDrop: {opted_state: ''},
      rewardExpirations: {opted_state: ''}
    }
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/myconfig/updateUserSettings');

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

req.type('json');
req.send({
  kind: '',
  notesExport: {
    folderName: '',
    isEnabled: false
  },
  notification: {
    matchMyInterests: {
      opted_state: ''
    },
    moreFromAuthors: {
      opted_state: ''
    },
    moreFromSeries: {
      opted_state: ''
    },
    priceDrop: {
      opted_state: ''
    },
    rewardExpirations: {
      opted_state: ''
    }
  }
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/myconfig/updateUserSettings',
  headers: {'content-type': 'application/json'},
  data: {
    kind: '',
    notesExport: {folderName: '', isEnabled: false},
    notification: {
      matchMyInterests: {opted_state: ''},
      moreFromAuthors: {opted_state: ''},
      moreFromSeries: {opted_state: ''},
      priceDrop: {opted_state: ''},
      rewardExpirations: {opted_state: ''}
    }
  }
};

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

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

const url = '{{baseUrl}}/books/v1/myconfig/updateUserSettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"kind":"","notesExport":{"folderName":"","isEnabled":false},"notification":{"matchMyInterests":{"opted_state":""},"moreFromAuthors":{"opted_state":""},"moreFromSeries":{"opted_state":""},"priceDrop":{"opted_state":""},"rewardExpirations":{"opted_state":""}}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"kind": @"",
                              @"notesExport": @{ @"folderName": @"", @"isEnabled": @NO },
                              @"notification": @{ @"matchMyInterests": @{ @"opted_state": @"" }, @"moreFromAuthors": @{ @"opted_state": @"" }, @"moreFromSeries": @{ @"opted_state": @"" }, @"priceDrop": @{ @"opted_state": @"" }, @"rewardExpirations": @{ @"opted_state": @"" } } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/myconfig/updateUserSettings"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/myconfig/updateUserSettings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}" in

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

 "{{baseUrl}}/books/v1/myconfig/updateUserSettings",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'kind' => '',
    'notesExport' => [
        'folderName' => '',
        'isEnabled' => null
    ],
    'notification' => [
        'matchMyInterests' => [
                'opted_state' => ''
        ],
        'moreFromAuthors' => [
                'opted_state' => ''
        ],
        'moreFromSeries' => [
                'opted_state' => ''
        ],
        'priceDrop' => [
                'opted_state' => ''
        ],
        'rewardExpirations' => [
                'opted_state' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/books/v1/myconfig/updateUserSettings', [
  'body' => '{
  "kind": "",
  "notesExport": {
    "folderName": "",
    "isEnabled": false
  },
  "notification": {
    "matchMyInterests": {
      "opted_state": ""
    },
    "moreFromAuthors": {
      "opted_state": ""
    },
    "moreFromSeries": {
      "opted_state": ""
    },
    "priceDrop": {
      "opted_state": ""
    },
    "rewardExpirations": {
      "opted_state": ""
    }
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/myconfig/updateUserSettings');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'kind' => '',
  'notesExport' => [
    'folderName' => '',
    'isEnabled' => null
  ],
  'notification' => [
    'matchMyInterests' => [
        'opted_state' => ''
    ],
    'moreFromAuthors' => [
        'opted_state' => ''
    ],
    'moreFromSeries' => [
        'opted_state' => ''
    ],
    'priceDrop' => [
        'opted_state' => ''
    ],
    'rewardExpirations' => [
        'opted_state' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'kind' => '',
  'notesExport' => [
    'folderName' => '',
    'isEnabled' => null
  ],
  'notification' => [
    'matchMyInterests' => [
        'opted_state' => ''
    ],
    'moreFromAuthors' => [
        'opted_state' => ''
    ],
    'moreFromSeries' => [
        'opted_state' => ''
    ],
    'priceDrop' => [
        'opted_state' => ''
    ],
    'rewardExpirations' => [
        'opted_state' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/books/v1/myconfig/updateUserSettings');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/myconfig/updateUserSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "kind": "",
  "notesExport": {
    "folderName": "",
    "isEnabled": false
  },
  "notification": {
    "matchMyInterests": {
      "opted_state": ""
    },
    "moreFromAuthors": {
      "opted_state": ""
    },
    "moreFromSeries": {
      "opted_state": ""
    },
    "priceDrop": {
      "opted_state": ""
    },
    "rewardExpirations": {
      "opted_state": ""
    }
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/myconfig/updateUserSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "kind": "",
  "notesExport": {
    "folderName": "",
    "isEnabled": false
  },
  "notification": {
    "matchMyInterests": {
      "opted_state": ""
    },
    "moreFromAuthors": {
      "opted_state": ""
    },
    "moreFromSeries": {
      "opted_state": ""
    },
    "priceDrop": {
      "opted_state": ""
    },
    "rewardExpirations": {
      "opted_state": ""
    }
  }
}'

import http.client

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

payload = "{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}"

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

conn.request("POST", "/baseUrl/books/v1/myconfig/updateUserSettings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/books/v1/myconfig/updateUserSettings"

payload = {
    "kind": "",
    "notesExport": {
        "folderName": "",
        "isEnabled": False
    },
    "notification": {
        "matchMyInterests": { "opted_state": "" },
        "moreFromAuthors": { "opted_state": "" },
        "moreFromSeries": { "opted_state": "" },
        "priceDrop": { "opted_state": "" },
        "rewardExpirations": { "opted_state": "" }
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/myconfig/updateUserSettings"

payload <- "{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/myconfig/updateUserSettings")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/books/v1/myconfig/updateUserSettings') do |req|
  req.body = "{\n  \"kind\": \"\",\n  \"notesExport\": {\n    \"folderName\": \"\",\n    \"isEnabled\": false\n  },\n  \"notification\": {\n    \"matchMyInterests\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromAuthors\": {\n      \"opted_state\": \"\"\n    },\n    \"moreFromSeries\": {\n      \"opted_state\": \"\"\n    },\n    \"priceDrop\": {\n      \"opted_state\": \"\"\n    },\n    \"rewardExpirations\": {\n      \"opted_state\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "kind": "",
        "notesExport": json!({
            "folderName": "",
            "isEnabled": false
        }),
        "notification": json!({
            "matchMyInterests": json!({"opted_state": ""}),
            "moreFromAuthors": json!({"opted_state": ""}),
            "moreFromSeries": json!({"opted_state": ""}),
            "priceDrop": json!({"opted_state": ""}),
            "rewardExpirations": json!({"opted_state": ""})
        })
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/books/v1/myconfig/updateUserSettings \
  --header 'content-type: application/json' \
  --data '{
  "kind": "",
  "notesExport": {
    "folderName": "",
    "isEnabled": false
  },
  "notification": {
    "matchMyInterests": {
      "opted_state": ""
    },
    "moreFromAuthors": {
      "opted_state": ""
    },
    "moreFromSeries": {
      "opted_state": ""
    },
    "priceDrop": {
      "opted_state": ""
    },
    "rewardExpirations": {
      "opted_state": ""
    }
  }
}'

echo '{
  "kind": "",
  "notesExport": {
    "folderName": "",
    "isEnabled": false
  },
  "notification": {
    "matchMyInterests": {
      "opted_state": ""
    },
    "moreFromAuthors": {
      "opted_state": ""
    },
    "moreFromSeries": {
      "opted_state": ""
    },
    "priceDrop": {
      "opted_state": ""
    },
    "rewardExpirations": {
      "opted_state": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/books/v1/myconfig/updateUserSettings \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "kind": "",\n  "notesExport": {\n    "folderName": "",\n    "isEnabled": false\n  },\n  "notification": {\n    "matchMyInterests": {\n      "opted_state": ""\n    },\n    "moreFromAuthors": {\n      "opted_state": ""\n    },\n    "moreFromSeries": {\n      "opted_state": ""\n    },\n    "priceDrop": {\n      "opted_state": ""\n    },\n    "rewardExpirations": {\n      "opted_state": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/books/v1/myconfig/updateUserSettings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "kind": "",
  "notesExport": [
    "folderName": "",
    "isEnabled": false
  ],
  "notification": [
    "matchMyInterests": ["opted_state": ""],
    "moreFromAuthors": ["opted_state": ""],
    "moreFromSeries": ["opted_state": ""],
    "priceDrop": ["opted_state": ""],
    "rewardExpirations": ["opted_state": ""]
  ]
] as [String : Any]

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

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

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

dataTask.resume()

DELETE books.mylibrary.annotations.delete

{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId

QUERY PARAMS

annotationId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"

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

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

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

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

}

DELETE /baseUrl/books/v1/mylibrary/annotations/:annotationId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId'
};

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

const url = '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/annotations/:annotationId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId'
};

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

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

const url = '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId" in

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

 "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/books/v1/mylibrary/annotations/:annotationId")

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

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

import requests

url = "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/books/v1/mylibrary/annotations/:annotationId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId";

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/books/v1/mylibrary/annotations/:annotationId

http DELETE {{baseUrl}}/books/v1/mylibrary/annotations/:annotationId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/books/v1/mylibrary/annotations/:annotationId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

POST books.mylibrary.annotations.insert

{{baseUrl}}/books/v1/mylibrary/annotations

BODY json

{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/annotations");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/books/v1/mylibrary/annotations" {:content-type :json
                                                                           :form-params {:afterSelectedText ""
                                                                                         :beforeSelectedText ""
                                                                                         :clientVersionRanges {:cfiRange {:endOffset ""
                                                                                                                          :endPosition ""
                                                                                                                          :startOffset ""
                                                                                                                          :startPosition ""}
                                                                                                               :contentVersion ""
                                                                                                               :gbImageRange {}
                                                                                                               :gbTextRange {}
                                                                                                               :imageCfiRange {}}
                                                                                         :created ""
                                                                                         :currentVersionRanges {:cfiRange {}
                                                                                                                :contentVersion ""
                                                                                                                :gbImageRange {}
                                                                                                                :gbTextRange {}
                                                                                                                :imageCfiRange {}}
                                                                                         :data ""
                                                                                         :deleted false
                                                                                         :highlightStyle ""
                                                                                         :id ""
                                                                                         :kind ""
                                                                                         :layerId ""
                                                                                         :layerSummary {:allowedCharacterCount 0
                                                                                                        :limitType ""
                                                                                                        :remainingCharacterCount 0}
                                                                                         :pageIds []
                                                                                         :selectedText ""
                                                                                         :selfLink ""
                                                                                         :updated ""
                                                                                         :volumeId ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/annotations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/mylibrary/annotations"),
    Content = new StringContent("{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/annotations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/annotations"

	payload := strings.NewReader("{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/books/v1/mylibrary/annotations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 781

{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/mylibrary/annotations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/annotations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/annotations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/mylibrary/annotations")
  .header("content-type", "application/json")
  .body("{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  afterSelectedText: '',
  beforeSelectedText: '',
  clientVersionRanges: {
    cfiRange: {
      endOffset: '',
      endPosition: '',
      startOffset: '',
      startPosition: ''
    },
    contentVersion: '',
    gbImageRange: {},
    gbTextRange: {},
    imageCfiRange: {}
  },
  created: '',
  currentVersionRanges: {
    cfiRange: {},
    contentVersion: '',
    gbImageRange: {},
    gbTextRange: {},
    imageCfiRange: {}
  },
  data: '',
  deleted: false,
  highlightStyle: '',
  id: '',
  kind: '',
  layerId: '',
  layerSummary: {
    allowedCharacterCount: 0,
    limitType: '',
    remainingCharacterCount: 0
  },
  pageIds: [],
  selectedText: '',
  selfLink: '',
  updated: '',
  volumeId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/books/v1/mylibrary/annotations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations',
  headers: {'content-type': 'application/json'},
  data: {
    afterSelectedText: '',
    beforeSelectedText: '',
    clientVersionRanges: {
      cfiRange: {endOffset: '', endPosition: '', startOffset: '', startPosition: ''},
      contentVersion: '',
      gbImageRange: {},
      gbTextRange: {},
      imageCfiRange: {}
    },
    created: '',
    currentVersionRanges: {
      cfiRange: {},
      contentVersion: '',
      gbImageRange: {},
      gbTextRange: {},
      imageCfiRange: {}
    },
    data: '',
    deleted: false,
    highlightStyle: '',
    id: '',
    kind: '',
    layerId: '',
    layerSummary: {allowedCharacterCount: 0, limitType: '', remainingCharacterCount: 0},
    pageIds: [],
    selectedText: '',
    selfLink: '',
    updated: '',
    volumeId: ''
  }
};

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

const url = '{{baseUrl}}/books/v1/mylibrary/annotations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"afterSelectedText":"","beforeSelectedText":"","clientVersionRanges":{"cfiRange":{"endOffset":"","endPosition":"","startOffset":"","startPosition":""},"contentVersion":"","gbImageRange":{},"gbTextRange":{},"imageCfiRange":{}},"created":"","currentVersionRanges":{"cfiRange":{},"contentVersion":"","gbImageRange":{},"gbTextRange":{},"imageCfiRange":{}},"data":"","deleted":false,"highlightStyle":"","id":"","kind":"","layerId":"","layerSummary":{"allowedCharacterCount":0,"limitType":"","remainingCharacterCount":0},"pageIds":[],"selectedText":"","selfLink":"","updated":"","volumeId":""}'
};

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}}/books/v1/mylibrary/annotations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "afterSelectedText": "",\n  "beforeSelectedText": "",\n  "clientVersionRanges": {\n    "cfiRange": {\n      "endOffset": "",\n      "endPosition": "",\n      "startOffset": "",\n      "startPosition": ""\n    },\n    "contentVersion": "",\n    "gbImageRange": {},\n    "gbTextRange": {},\n    "imageCfiRange": {}\n  },\n  "created": "",\n  "currentVersionRanges": {\n    "cfiRange": {},\n    "contentVersion": "",\n    "gbImageRange": {},\n    "gbTextRange": {},\n    "imageCfiRange": {}\n  },\n  "data": "",\n  "deleted": false,\n  "highlightStyle": "",\n  "id": "",\n  "kind": "",\n  "layerId": "",\n  "layerSummary": {\n    "allowedCharacterCount": 0,\n    "limitType": "",\n    "remainingCharacterCount": 0\n  },\n  "pageIds": [],\n  "selectedText": "",\n  "selfLink": "",\n  "updated": "",\n  "volumeId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/annotations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/annotations',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  afterSelectedText: '',
  beforeSelectedText: '',
  clientVersionRanges: {
    cfiRange: {endOffset: '', endPosition: '', startOffset: '', startPosition: ''},
    contentVersion: '',
    gbImageRange: {},
    gbTextRange: {},
    imageCfiRange: {}
  },
  created: '',
  currentVersionRanges: {
    cfiRange: {},
    contentVersion: '',
    gbImageRange: {},
    gbTextRange: {},
    imageCfiRange: {}
  },
  data: '',
  deleted: false,
  highlightStyle: '',
  id: '',
  kind: '',
  layerId: '',
  layerSummary: {allowedCharacterCount: 0, limitType: '', remainingCharacterCount: 0},
  pageIds: [],
  selectedText: '',
  selfLink: '',
  updated: '',
  volumeId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations',
  headers: {'content-type': 'application/json'},
  body: {
    afterSelectedText: '',
    beforeSelectedText: '',
    clientVersionRanges: {
      cfiRange: {endOffset: '', endPosition: '', startOffset: '', startPosition: ''},
      contentVersion: '',
      gbImageRange: {},
      gbTextRange: {},
      imageCfiRange: {}
    },
    created: '',
    currentVersionRanges: {
      cfiRange: {},
      contentVersion: '',
      gbImageRange: {},
      gbTextRange: {},
      imageCfiRange: {}
    },
    data: '',
    deleted: false,
    highlightStyle: '',
    id: '',
    kind: '',
    layerId: '',
    layerSummary: {allowedCharacterCount: 0, limitType: '', remainingCharacterCount: 0},
    pageIds: [],
    selectedText: '',
    selfLink: '',
    updated: '',
    volumeId: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/mylibrary/annotations');

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

req.type('json');
req.send({
  afterSelectedText: '',
  beforeSelectedText: '',
  clientVersionRanges: {
    cfiRange: {
      endOffset: '',
      endPosition: '',
      startOffset: '',
      startPosition: ''
    },
    contentVersion: '',
    gbImageRange: {},
    gbTextRange: {},
    imageCfiRange: {}
  },
  created: '',
  currentVersionRanges: {
    cfiRange: {},
    contentVersion: '',
    gbImageRange: {},
    gbTextRange: {},
    imageCfiRange: {}
  },
  data: '',
  deleted: false,
  highlightStyle: '',
  id: '',
  kind: '',
  layerId: '',
  layerSummary: {
    allowedCharacterCount: 0,
    limitType: '',
    remainingCharacterCount: 0
  },
  pageIds: [],
  selectedText: '',
  selfLink: '',
  updated: '',
  volumeId: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations',
  headers: {'content-type': 'application/json'},
  data: {
    afterSelectedText: '',
    beforeSelectedText: '',
    clientVersionRanges: {
      cfiRange: {endOffset: '', endPosition: '', startOffset: '', startPosition: ''},
      contentVersion: '',
      gbImageRange: {},
      gbTextRange: {},
      imageCfiRange: {}
    },
    created: '',
    currentVersionRanges: {
      cfiRange: {},
      contentVersion: '',
      gbImageRange: {},
      gbTextRange: {},
      imageCfiRange: {}
    },
    data: '',
    deleted: false,
    highlightStyle: '',
    id: '',
    kind: '',
    layerId: '',
    layerSummary: {allowedCharacterCount: 0, limitType: '', remainingCharacterCount: 0},
    pageIds: [],
    selectedText: '',
    selfLink: '',
    updated: '',
    volumeId: ''
  }
};

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

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

const url = '{{baseUrl}}/books/v1/mylibrary/annotations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"afterSelectedText":"","beforeSelectedText":"","clientVersionRanges":{"cfiRange":{"endOffset":"","endPosition":"","startOffset":"","startPosition":""},"contentVersion":"","gbImageRange":{},"gbTextRange":{},"imageCfiRange":{}},"created":"","currentVersionRanges":{"cfiRange":{},"contentVersion":"","gbImageRange":{},"gbTextRange":{},"imageCfiRange":{}},"data":"","deleted":false,"highlightStyle":"","id":"","kind":"","layerId":"","layerSummary":{"allowedCharacterCount":0,"limitType":"","remainingCharacterCount":0},"pageIds":[],"selectedText":"","selfLink":"","updated":"","volumeId":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"afterSelectedText": @"",
                              @"beforeSelectedText": @"",
                              @"clientVersionRanges": @{ @"cfiRange": @{ @"endOffset": @"", @"endPosition": @"", @"startOffset": @"", @"startPosition": @"" }, @"contentVersion": @"", @"gbImageRange": @{  }, @"gbTextRange": @{  }, @"imageCfiRange": @{  } },
                              @"created": @"",
                              @"currentVersionRanges": @{ @"cfiRange": @{  }, @"contentVersion": @"", @"gbImageRange": @{  }, @"gbTextRange": @{  }, @"imageCfiRange": @{  } },
                              @"data": @"",
                              @"deleted": @NO,
                              @"highlightStyle": @"",
                              @"id": @"",
                              @"kind": @"",
                              @"layerId": @"",
                              @"layerSummary": @{ @"allowedCharacterCount": @0, @"limitType": @"", @"remainingCharacterCount": @0 },
                              @"pageIds": @[  ],
                              @"selectedText": @"",
                              @"selfLink": @"",
                              @"updated": @"",
                              @"volumeId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/mylibrary/annotations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/mylibrary/annotations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}" in

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

 "{{baseUrl}}/books/v1/mylibrary/annotations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'afterSelectedText' => '',
    'beforeSelectedText' => '',
    'clientVersionRanges' => [
        'cfiRange' => [
                'endOffset' => '',
                'endPosition' => '',
                'startOffset' => '',
                'startPosition' => ''
        ],
        'contentVersion' => '',
        'gbImageRange' => [
                
        ],
        'gbTextRange' => [
                
        ],
        'imageCfiRange' => [
                
        ]
    ],
    'created' => '',
    'currentVersionRanges' => [
        'cfiRange' => [
                
        ],
        'contentVersion' => '',
        'gbImageRange' => [
                
        ],
        'gbTextRange' => [
                
        ],
        'imageCfiRange' => [
                
        ]
    ],
    'data' => '',
    'deleted' => null,
    'highlightStyle' => '',
    'id' => '',
    'kind' => '',
    'layerId' => '',
    'layerSummary' => [
        'allowedCharacterCount' => 0,
        'limitType' => '',
        'remainingCharacterCount' => 0
    ],
    'pageIds' => [
        
    ],
    'selectedText' => '',
    'selfLink' => '',
    'updated' => '',
    'volumeId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/books/v1/mylibrary/annotations', [
  'body' => '{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/annotations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'afterSelectedText' => '',
  'beforeSelectedText' => '',
  'clientVersionRanges' => [
    'cfiRange' => [
        'endOffset' => '',
        'endPosition' => '',
        'startOffset' => '',
        'startPosition' => ''
    ],
    'contentVersion' => '',
    'gbImageRange' => [
        
    ],
    'gbTextRange' => [
        
    ],
    'imageCfiRange' => [
        
    ]
  ],
  'created' => '',
  'currentVersionRanges' => [
    'cfiRange' => [
        
    ],
    'contentVersion' => '',
    'gbImageRange' => [
        
    ],
    'gbTextRange' => [
        
    ],
    'imageCfiRange' => [
        
    ]
  ],
  'data' => '',
  'deleted' => null,
  'highlightStyle' => '',
  'id' => '',
  'kind' => '',
  'layerId' => '',
  'layerSummary' => [
    'allowedCharacterCount' => 0,
    'limitType' => '',
    'remainingCharacterCount' => 0
  ],
  'pageIds' => [
    
  ],
  'selectedText' => '',
  'selfLink' => '',
  'updated' => '',
  'volumeId' => ''
]));

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

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

append(json_encode([
  'afterSelectedText' => '',
  'beforeSelectedText' => '',
  'clientVersionRanges' => [
    'cfiRange' => [
        'endOffset' => '',
        'endPosition' => '',
        'startOffset' => '',
        'startPosition' => ''
    ],
    'contentVersion' => '',
    'gbImageRange' => [
        
    ],
    'gbTextRange' => [
        
    ],
    'imageCfiRange' => [
        
    ]
  ],
  'created' => '',
  'currentVersionRanges' => [
    'cfiRange' => [
        
    ],
    'contentVersion' => '',
    'gbImageRange' => [
        
    ],
    'gbTextRange' => [
        
    ],
    'imageCfiRange' => [
        
    ]
  ],
  'data' => '',
  'deleted' => null,
  'highlightStyle' => '',
  'id' => '',
  'kind' => '',
  'layerId' => '',
  'layerSummary' => [
    'allowedCharacterCount' => 0,
    'limitType' => '',
    'remainingCharacterCount' => 0
  ],
  'pageIds' => [
    
  ],
  'selectedText' => '',
  'selfLink' => '',
  'updated' => '',
  'volumeId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/books/v1/mylibrary/annotations');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/annotations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/annotations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}'

import http.client

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

payload = "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/books/v1/mylibrary/annotations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/books/v1/mylibrary/annotations"

payload = {
    "afterSelectedText": "",
    "beforeSelectedText": "",
    "clientVersionRanges": {
        "cfiRange": {
            "endOffset": "",
            "endPosition": "",
            "startOffset": "",
            "startPosition": ""
        },
        "contentVersion": "",
        "gbImageRange": {},
        "gbTextRange": {},
        "imageCfiRange": {}
    },
    "created": "",
    "currentVersionRanges": {
        "cfiRange": {},
        "contentVersion": "",
        "gbImageRange": {},
        "gbTextRange": {},
        "imageCfiRange": {}
    },
    "data": "",
    "deleted": False,
    "highlightStyle": "",
    "id": "",
    "kind": "",
    "layerId": "",
    "layerSummary": {
        "allowedCharacterCount": 0,
        "limitType": "",
        "remainingCharacterCount": 0
    },
    "pageIds": [],
    "selectedText": "",
    "selfLink": "",
    "updated": "",
    "volumeId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/annotations"

payload <- "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/annotations")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/books/v1/mylibrary/annotations') do |req|
  req.body = "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "afterSelectedText": "",
        "beforeSelectedText": "",
        "clientVersionRanges": json!({
            "cfiRange": json!({
                "endOffset": "",
                "endPosition": "",
                "startOffset": "",
                "startPosition": ""
            }),
            "contentVersion": "",
            "gbImageRange": json!({}),
            "gbTextRange": json!({}),
            "imageCfiRange": json!({})
        }),
        "created": "",
        "currentVersionRanges": json!({
            "cfiRange": json!({}),
            "contentVersion": "",
            "gbImageRange": json!({}),
            "gbTextRange": json!({}),
            "imageCfiRange": json!({})
        }),
        "data": "",
        "deleted": false,
        "highlightStyle": "",
        "id": "",
        "kind": "",
        "layerId": "",
        "layerSummary": json!({
            "allowedCharacterCount": 0,
            "limitType": "",
            "remainingCharacterCount": 0
        }),
        "pageIds": (),
        "selectedText": "",
        "selfLink": "",
        "updated": "",
        "volumeId": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/books/v1/mylibrary/annotations \
  --header 'content-type: application/json' \
  --data '{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}'

echo '{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}' |  \
  http POST {{baseUrl}}/books/v1/mylibrary/annotations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "afterSelectedText": "",\n  "beforeSelectedText": "",\n  "clientVersionRanges": {\n    "cfiRange": {\n      "endOffset": "",\n      "endPosition": "",\n      "startOffset": "",\n      "startPosition": ""\n    },\n    "contentVersion": "",\n    "gbImageRange": {},\n    "gbTextRange": {},\n    "imageCfiRange": {}\n  },\n  "created": "",\n  "currentVersionRanges": {\n    "cfiRange": {},\n    "contentVersion": "",\n    "gbImageRange": {},\n    "gbTextRange": {},\n    "imageCfiRange": {}\n  },\n  "data": "",\n  "deleted": false,\n  "highlightStyle": "",\n  "id": "",\n  "kind": "",\n  "layerId": "",\n  "layerSummary": {\n    "allowedCharacterCount": 0,\n    "limitType": "",\n    "remainingCharacterCount": 0\n  },\n  "pageIds": [],\n  "selectedText": "",\n  "selfLink": "",\n  "updated": "",\n  "volumeId": ""\n}' \
  --output-document \
  - {{baseUrl}}/books/v1/mylibrary/annotations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": [
    "cfiRange": [
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    ],
    "contentVersion": "",
    "gbImageRange": [],
    "gbTextRange": [],
    "imageCfiRange": []
  ],
  "created": "",
  "currentVersionRanges": [
    "cfiRange": [],
    "contentVersion": "",
    "gbImageRange": [],
    "gbTextRange": [],
    "imageCfiRange": []
  ],
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": [
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  ],
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
] as [String : Any]

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

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

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

dataTask.resume()

GET books.mylibrary.annotations.list

{{baseUrl}}/books/v1/mylibrary/annotations

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/annotations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/books/v1/mylibrary/annotations")

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/annotations"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/annotations"

	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/books/v1/mylibrary/annotations HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/annotations")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/mylibrary/annotations');

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}}/books/v1/mylibrary/annotations'
};

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

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

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

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

 "{{baseUrl}}/books/v1/mylibrary/annotations",
  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}}/books/v1/mylibrary/annotations');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/annotations');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/annotations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/annotations' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/books/v1/mylibrary/annotations")

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

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

import requests

url = "{{baseUrl}}/books/v1/mylibrary/annotations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/annotations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/annotations")

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/books/v1/mylibrary/annotations') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/books/v1/mylibrary/annotations

http GET {{baseUrl}}/books/v1/mylibrary/annotations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/mylibrary/annotations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/annotations")! 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()

POST books.mylibrary.annotations.summary

{{baseUrl}}/books/v1/mylibrary/annotations/summary

QUERY PARAMS

layerIds

volumeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/books/v1/mylibrary/annotations/summary" {:query-params {:layerIds ""
                                                                                                  :volumeId ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId="

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId="

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

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

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

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

}

POST /baseUrl/books/v1/mylibrary/annotations/summary?layerIds=&volumeId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations/summary',
  params: {layerIds: '', volumeId: ''}
};

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

const url = '{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations/summary',
  qs: {layerIds: '', volumeId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/mylibrary/annotations/summary');

req.query({
  layerIds: '',
  volumeId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations/summary',
  params: {layerIds: '', volumeId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/annotations/summary');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'layerIds' => '',
  'volumeId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/mylibrary/annotations/summary');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'layerIds' => '',
  'volumeId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/mylibrary/annotations/summary"

querystring = {"layerIds":"","volumeId":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/annotations/summary"

queryString <- list(
  layerIds = "",
  volumeId = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/books/v1/mylibrary/annotations/summary') do |req|
  req.params['layerIds'] = ''
  req.params['volumeId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/mylibrary/annotations/summary";

    let querystring = [
        ("layerIds", ""),
        ("volumeId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId='

http POST '{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/annotations/summary?layerIds=&volumeId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT books.mylibrary.annotations.update

{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId

QUERY PARAMS

annotationId

BODY json

{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId" {:content-type :json
                                                                                        :form-params {:afterSelectedText ""
                                                                                                      :beforeSelectedText ""
                                                                                                      :clientVersionRanges {:cfiRange {:endOffset ""
                                                                                                                                       :endPosition ""
                                                                                                                                       :startOffset ""
                                                                                                                                       :startPosition ""}
                                                                                                                            :contentVersion ""
                                                                                                                            :gbImageRange {}
                                                                                                                            :gbTextRange {}
                                                                                                                            :imageCfiRange {}}
                                                                                                      :created ""
                                                                                                      :currentVersionRanges {:cfiRange {}
                                                                                                                             :contentVersion ""
                                                                                                                             :gbImageRange {}
                                                                                                                             :gbTextRange {}
                                                                                                                             :imageCfiRange {}}
                                                                                                      :data ""
                                                                                                      :deleted false
                                                                                                      :highlightStyle ""
                                                                                                      :id ""
                                                                                                      :kind ""
                                                                                                      :layerId ""
                                                                                                      :layerSummary {:allowedCharacterCount 0
                                                                                                                     :limitType ""
                                                                                                                     :remainingCharacterCount 0}
                                                                                                      :pageIds []
                                                                                                      :selectedText ""
                                                                                                      :selfLink ""
                                                                                                      :updated ""
                                                                                                      :volumeId ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"),
    Content = new StringContent("{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"

	payload := strings.NewReader("{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/books/v1/mylibrary/annotations/:annotationId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 781

{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")
  .header("content-type", "application/json")
  .body("{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  afterSelectedText: '',
  beforeSelectedText: '',
  clientVersionRanges: {
    cfiRange: {
      endOffset: '',
      endPosition: '',
      startOffset: '',
      startPosition: ''
    },
    contentVersion: '',
    gbImageRange: {},
    gbTextRange: {},
    imageCfiRange: {}
  },
  created: '',
  currentVersionRanges: {
    cfiRange: {},
    contentVersion: '',
    gbImageRange: {},
    gbTextRange: {},
    imageCfiRange: {}
  },
  data: '',
  deleted: false,
  highlightStyle: '',
  id: '',
  kind: '',
  layerId: '',
  layerSummary: {
    allowedCharacterCount: 0,
    limitType: '',
    remainingCharacterCount: 0
  },
  pageIds: [],
  selectedText: '',
  selfLink: '',
  updated: '',
  volumeId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId',
  headers: {'content-type': 'application/json'},
  data: {
    afterSelectedText: '',
    beforeSelectedText: '',
    clientVersionRanges: {
      cfiRange: {endOffset: '', endPosition: '', startOffset: '', startPosition: ''},
      contentVersion: '',
      gbImageRange: {},
      gbTextRange: {},
      imageCfiRange: {}
    },
    created: '',
    currentVersionRanges: {
      cfiRange: {},
      contentVersion: '',
      gbImageRange: {},
      gbTextRange: {},
      imageCfiRange: {}
    },
    data: '',
    deleted: false,
    highlightStyle: '',
    id: '',
    kind: '',
    layerId: '',
    layerSummary: {allowedCharacterCount: 0, limitType: '', remainingCharacterCount: 0},
    pageIds: [],
    selectedText: '',
    selfLink: '',
    updated: '',
    volumeId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"afterSelectedText":"","beforeSelectedText":"","clientVersionRanges":{"cfiRange":{"endOffset":"","endPosition":"","startOffset":"","startPosition":""},"contentVersion":"","gbImageRange":{},"gbTextRange":{},"imageCfiRange":{}},"created":"","currentVersionRanges":{"cfiRange":{},"contentVersion":"","gbImageRange":{},"gbTextRange":{},"imageCfiRange":{}},"data":"","deleted":false,"highlightStyle":"","id":"","kind":"","layerId":"","layerSummary":{"allowedCharacterCount":0,"limitType":"","remainingCharacterCount":0},"pageIds":[],"selectedText":"","selfLink":"","updated":"","volumeId":""}'
};

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}}/books/v1/mylibrary/annotations/:annotationId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "afterSelectedText": "",\n  "beforeSelectedText": "",\n  "clientVersionRanges": {\n    "cfiRange": {\n      "endOffset": "",\n      "endPosition": "",\n      "startOffset": "",\n      "startPosition": ""\n    },\n    "contentVersion": "",\n    "gbImageRange": {},\n    "gbTextRange": {},\n    "imageCfiRange": {}\n  },\n  "created": "",\n  "currentVersionRanges": {\n    "cfiRange": {},\n    "contentVersion": "",\n    "gbImageRange": {},\n    "gbTextRange": {},\n    "imageCfiRange": {}\n  },\n  "data": "",\n  "deleted": false,\n  "highlightStyle": "",\n  "id": "",\n  "kind": "",\n  "layerId": "",\n  "layerSummary": {\n    "allowedCharacterCount": 0,\n    "limitType": "",\n    "remainingCharacterCount": 0\n  },\n  "pageIds": [],\n  "selectedText": "",\n  "selfLink": "",\n  "updated": "",\n  "volumeId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/annotations/:annotationId',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  afterSelectedText: '',
  beforeSelectedText: '',
  clientVersionRanges: {
    cfiRange: {endOffset: '', endPosition: '', startOffset: '', startPosition: ''},
    contentVersion: '',
    gbImageRange: {},
    gbTextRange: {},
    imageCfiRange: {}
  },
  created: '',
  currentVersionRanges: {
    cfiRange: {},
    contentVersion: '',
    gbImageRange: {},
    gbTextRange: {},
    imageCfiRange: {}
  },
  data: '',
  deleted: false,
  highlightStyle: '',
  id: '',
  kind: '',
  layerId: '',
  layerSummary: {allowedCharacterCount: 0, limitType: '', remainingCharacterCount: 0},
  pageIds: [],
  selectedText: '',
  selfLink: '',
  updated: '',
  volumeId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId',
  headers: {'content-type': 'application/json'},
  body: {
    afterSelectedText: '',
    beforeSelectedText: '',
    clientVersionRanges: {
      cfiRange: {endOffset: '', endPosition: '', startOffset: '', startPosition: ''},
      contentVersion: '',
      gbImageRange: {},
      gbTextRange: {},
      imageCfiRange: {}
    },
    created: '',
    currentVersionRanges: {
      cfiRange: {},
      contentVersion: '',
      gbImageRange: {},
      gbTextRange: {},
      imageCfiRange: {}
    },
    data: '',
    deleted: false,
    highlightStyle: '',
    id: '',
    kind: '',
    layerId: '',
    layerSummary: {allowedCharacterCount: 0, limitType: '', remainingCharacterCount: 0},
    pageIds: [],
    selectedText: '',
    selfLink: '',
    updated: '',
    volumeId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  afterSelectedText: '',
  beforeSelectedText: '',
  clientVersionRanges: {
    cfiRange: {
      endOffset: '',
      endPosition: '',
      startOffset: '',
      startPosition: ''
    },
    contentVersion: '',
    gbImageRange: {},
    gbTextRange: {},
    imageCfiRange: {}
  },
  created: '',
  currentVersionRanges: {
    cfiRange: {},
    contentVersion: '',
    gbImageRange: {},
    gbTextRange: {},
    imageCfiRange: {}
  },
  data: '',
  deleted: false,
  highlightStyle: '',
  id: '',
  kind: '',
  layerId: '',
  layerSummary: {
    allowedCharacterCount: 0,
    limitType: '',
    remainingCharacterCount: 0
  },
  pageIds: [],
  selectedText: '',
  selfLink: '',
  updated: '',
  volumeId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId',
  headers: {'content-type': 'application/json'},
  data: {
    afterSelectedText: '',
    beforeSelectedText: '',
    clientVersionRanges: {
      cfiRange: {endOffset: '', endPosition: '', startOffset: '', startPosition: ''},
      contentVersion: '',
      gbImageRange: {},
      gbTextRange: {},
      imageCfiRange: {}
    },
    created: '',
    currentVersionRanges: {
      cfiRange: {},
      contentVersion: '',
      gbImageRange: {},
      gbTextRange: {},
      imageCfiRange: {}
    },
    data: '',
    deleted: false,
    highlightStyle: '',
    id: '',
    kind: '',
    layerId: '',
    layerSummary: {allowedCharacterCount: 0, limitType: '', remainingCharacterCount: 0},
    pageIds: [],
    selectedText: '',
    selfLink: '',
    updated: '',
    volumeId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"afterSelectedText":"","beforeSelectedText":"","clientVersionRanges":{"cfiRange":{"endOffset":"","endPosition":"","startOffset":"","startPosition":""},"contentVersion":"","gbImageRange":{},"gbTextRange":{},"imageCfiRange":{}},"created":"","currentVersionRanges":{"cfiRange":{},"contentVersion":"","gbImageRange":{},"gbTextRange":{},"imageCfiRange":{}},"data":"","deleted":false,"highlightStyle":"","id":"","kind":"","layerId":"","layerSummary":{"allowedCharacterCount":0,"limitType":"","remainingCharacterCount":0},"pageIds":[],"selectedText":"","selfLink":"","updated":"","volumeId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"afterSelectedText": @"",
                              @"beforeSelectedText": @"",
                              @"clientVersionRanges": @{ @"cfiRange": @{ @"endOffset": @"", @"endPosition": @"", @"startOffset": @"", @"startPosition": @"" }, @"contentVersion": @"", @"gbImageRange": @{  }, @"gbTextRange": @{  }, @"imageCfiRange": @{  } },
                              @"created": @"",
                              @"currentVersionRanges": @{ @"cfiRange": @{  }, @"contentVersion": @"", @"gbImageRange": @{  }, @"gbTextRange": @{  }, @"imageCfiRange": @{  } },
                              @"data": @"",
                              @"deleted": @NO,
                              @"highlightStyle": @"",
                              @"id": @"",
                              @"kind": @"",
                              @"layerId": @"",
                              @"layerSummary": @{ @"allowedCharacterCount": @0, @"limitType": @"", @"remainingCharacterCount": @0 },
                              @"pageIds": @[  ],
                              @"selectedText": @"",
                              @"selfLink": @"",
                              @"updated": @"",
                              @"volumeId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'afterSelectedText' => '',
    'beforeSelectedText' => '',
    'clientVersionRanges' => [
        'cfiRange' => [
                'endOffset' => '',
                'endPosition' => '',
                'startOffset' => '',
                'startPosition' => ''
        ],
        'contentVersion' => '',
        'gbImageRange' => [
                
        ],
        'gbTextRange' => [
                
        ],
        'imageCfiRange' => [
                
        ]
    ],
    'created' => '',
    'currentVersionRanges' => [
        'cfiRange' => [
                
        ],
        'contentVersion' => '',
        'gbImageRange' => [
                
        ],
        'gbTextRange' => [
                
        ],
        'imageCfiRange' => [
                
        ]
    ],
    'data' => '',
    'deleted' => null,
    'highlightStyle' => '',
    'id' => '',
    'kind' => '',
    'layerId' => '',
    'layerSummary' => [
        'allowedCharacterCount' => 0,
        'limitType' => '',
        'remainingCharacterCount' => 0
    ],
    'pageIds' => [
        
    ],
    'selectedText' => '',
    'selfLink' => '',
    'updated' => '',
    'volumeId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId', [
  'body' => '{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'afterSelectedText' => '',
  'beforeSelectedText' => '',
  'clientVersionRanges' => [
    'cfiRange' => [
        'endOffset' => '',
        'endPosition' => '',
        'startOffset' => '',
        'startPosition' => ''
    ],
    'contentVersion' => '',
    'gbImageRange' => [
        
    ],
    'gbTextRange' => [
        
    ],
    'imageCfiRange' => [
        
    ]
  ],
  'created' => '',
  'currentVersionRanges' => [
    'cfiRange' => [
        
    ],
    'contentVersion' => '',
    'gbImageRange' => [
        
    ],
    'gbTextRange' => [
        
    ],
    'imageCfiRange' => [
        
    ]
  ],
  'data' => '',
  'deleted' => null,
  'highlightStyle' => '',
  'id' => '',
  'kind' => '',
  'layerId' => '',
  'layerSummary' => [
    'allowedCharacterCount' => 0,
    'limitType' => '',
    'remainingCharacterCount' => 0
  ],
  'pageIds' => [
    
  ],
  'selectedText' => '',
  'selfLink' => '',
  'updated' => '',
  'volumeId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'afterSelectedText' => '',
  'beforeSelectedText' => '',
  'clientVersionRanges' => [
    'cfiRange' => [
        'endOffset' => '',
        'endPosition' => '',
        'startOffset' => '',
        'startPosition' => ''
    ],
    'contentVersion' => '',
    'gbImageRange' => [
        
    ],
    'gbTextRange' => [
        
    ],
    'imageCfiRange' => [
        
    ]
  ],
  'created' => '',
  'currentVersionRanges' => [
    'cfiRange' => [
        
    ],
    'contentVersion' => '',
    'gbImageRange' => [
        
    ],
    'gbTextRange' => [
        
    ],
    'imageCfiRange' => [
        
    ]
  ],
  'data' => '',
  'deleted' => null,
  'highlightStyle' => '',
  'id' => '',
  'kind' => '',
  'layerId' => '',
  'layerSummary' => [
    'allowedCharacterCount' => 0,
    'limitType' => '',
    'remainingCharacterCount' => 0
  ],
  'pageIds' => [
    
  ],
  'selectedText' => '',
  'selfLink' => '',
  'updated' => '',
  'volumeId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/books/v1/mylibrary/annotations/:annotationId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"

payload = {
    "afterSelectedText": "",
    "beforeSelectedText": "",
    "clientVersionRanges": {
        "cfiRange": {
            "endOffset": "",
            "endPosition": "",
            "startOffset": "",
            "startPosition": ""
        },
        "contentVersion": "",
        "gbImageRange": {},
        "gbTextRange": {},
        "imageCfiRange": {}
    },
    "created": "",
    "currentVersionRanges": {
        "cfiRange": {},
        "contentVersion": "",
        "gbImageRange": {},
        "gbTextRange": {},
        "imageCfiRange": {}
    },
    "data": "",
    "deleted": False,
    "highlightStyle": "",
    "id": "",
    "kind": "",
    "layerId": "",
    "layerSummary": {
        "allowedCharacterCount": 0,
        "limitType": "",
        "remainingCharacterCount": 0
    },
    "pageIds": [],
    "selectedText": "",
    "selfLink": "",
    "updated": "",
    "volumeId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId"

payload <- "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/books/v1/mylibrary/annotations/:annotationId') do |req|
  req.body = "{\n  \"afterSelectedText\": \"\",\n  \"beforeSelectedText\": \"\",\n  \"clientVersionRanges\": {\n    \"cfiRange\": {\n      \"endOffset\": \"\",\n      \"endPosition\": \"\",\n      \"startOffset\": \"\",\n      \"startPosition\": \"\"\n    },\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"created\": \"\",\n  \"currentVersionRanges\": {\n    \"cfiRange\": {},\n    \"contentVersion\": \"\",\n    \"gbImageRange\": {},\n    \"gbTextRange\": {},\n    \"imageCfiRange\": {}\n  },\n  \"data\": \"\",\n  \"deleted\": false,\n  \"highlightStyle\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"layerId\": \"\",\n  \"layerSummary\": {\n    \"allowedCharacterCount\": 0,\n    \"limitType\": \"\",\n    \"remainingCharacterCount\": 0\n  },\n  \"pageIds\": [],\n  \"selectedText\": \"\",\n  \"selfLink\": \"\",\n  \"updated\": \"\",\n  \"volumeId\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId";

    let payload = json!({
        "afterSelectedText": "",
        "beforeSelectedText": "",
        "clientVersionRanges": json!({
            "cfiRange": json!({
                "endOffset": "",
                "endPosition": "",
                "startOffset": "",
                "startPosition": ""
            }),
            "contentVersion": "",
            "gbImageRange": json!({}),
            "gbTextRange": json!({}),
            "imageCfiRange": json!({})
        }),
        "created": "",
        "currentVersionRanges": json!({
            "cfiRange": json!({}),
            "contentVersion": "",
            "gbImageRange": json!({}),
            "gbTextRange": json!({}),
            "imageCfiRange": json!({})
        }),
        "data": "",
        "deleted": false,
        "highlightStyle": "",
        "id": "",
        "kind": "",
        "layerId": "",
        "layerSummary": json!({
            "allowedCharacterCount": 0,
            "limitType": "",
            "remainingCharacterCount": 0
        }),
        "pageIds": (),
        "selectedText": "",
        "selfLink": "",
        "updated": "",
        "volumeId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/books/v1/mylibrary/annotations/:annotationId \
  --header 'content-type: application/json' \
  --data '{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}'

echo '{
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": {
    "cfiRange": {
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    },
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "created": "",
  "currentVersionRanges": {
    "cfiRange": {},
    "contentVersion": "",
    "gbImageRange": {},
    "gbTextRange": {},
    "imageCfiRange": {}
  },
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": {
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  },
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
}' |  \
  http PUT {{baseUrl}}/books/v1/mylibrary/annotations/:annotationId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "afterSelectedText": "",\n  "beforeSelectedText": "",\n  "clientVersionRanges": {\n    "cfiRange": {\n      "endOffset": "",\n      "endPosition": "",\n      "startOffset": "",\n      "startPosition": ""\n    },\n    "contentVersion": "",\n    "gbImageRange": {},\n    "gbTextRange": {},\n    "imageCfiRange": {}\n  },\n  "created": "",\n  "currentVersionRanges": {\n    "cfiRange": {},\n    "contentVersion": "",\n    "gbImageRange": {},\n    "gbTextRange": {},\n    "imageCfiRange": {}\n  },\n  "data": "",\n  "deleted": false,\n  "highlightStyle": "",\n  "id": "",\n  "kind": "",\n  "layerId": "",\n  "layerSummary": {\n    "allowedCharacterCount": 0,\n    "limitType": "",\n    "remainingCharacterCount": 0\n  },\n  "pageIds": [],\n  "selectedText": "",\n  "selfLink": "",\n  "updated": "",\n  "volumeId": ""\n}' \
  --output-document \
  - {{baseUrl}}/books/v1/mylibrary/annotations/:annotationId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "afterSelectedText": "",
  "beforeSelectedText": "",
  "clientVersionRanges": [
    "cfiRange": [
      "endOffset": "",
      "endPosition": "",
      "startOffset": "",
      "startPosition": ""
    ],
    "contentVersion": "",
    "gbImageRange": [],
    "gbTextRange": [],
    "imageCfiRange": []
  ],
  "created": "",
  "currentVersionRanges": [
    "cfiRange": [],
    "contentVersion": "",
    "gbImageRange": [],
    "gbTextRange": [],
    "imageCfiRange": []
  ],
  "data": "",
  "deleted": false,
  "highlightStyle": "",
  "id": "",
  "kind": "",
  "layerId": "",
  "layerSummary": [
    "allowedCharacterCount": 0,
    "limitType": "",
    "remainingCharacterCount": 0
  ],
  "pageIds": [],
  "selectedText": "",
  "selfLink": "",
  "updated": "",
  "volumeId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/annotations/:annotationId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST books.mylibrary.bookshelves.addVolume

{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume

QUERY PARAMS

volumeId

shelf

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume" {:query-params {:volumeId ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume',
  params: {volumeId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume',
  qs: {volumeId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume');

req.query({
  volumeId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume',
  params: {volumeId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'volumeId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'volumeId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume"

querystring = {"volumeId":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume"

queryString <- list(volumeId = "")

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/books/v1/mylibrary/bookshelves/:shelf/addVolume') do |req|
  req.params['volumeId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume";

    let querystring = [
        ("volumeId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId='

http POST '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/addVolume?volumeId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST books.mylibrary.bookshelves.clearVolumes

{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes

QUERY PARAMS

shelf

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes")

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/books/v1/mylibrary/bookshelves/:shelf/clearVolumes HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/bookshelves/:shelf/clearVolumes',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/books/v1/mylibrary/bookshelves/:shelf/clearVolumes")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/books/v1/mylibrary/bookshelves/:shelf/clearVolumes') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes

http POST {{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/clearVolumes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET books.mylibrary.bookshelves.get

{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf

QUERY PARAMS

shelf

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf")

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf"

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}}/books/v1/mylibrary/bookshelves/:shelf"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf"

	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/books/v1/mylibrary/bookshelves/:shelf HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf"))
    .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}}/books/v1/mylibrary/bookshelves/:shelf")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf")
  .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}}/books/v1/mylibrary/bookshelves/:shelf');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf';
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}}/books/v1/mylibrary/bookshelves/:shelf',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/bookshelves/:shelf',
  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}}/books/v1/mylibrary/bookshelves/:shelf'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf');

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}}/books/v1/mylibrary/bookshelves/:shelf'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf';
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}}/books/v1/mylibrary/bookshelves/:shelf"]
                                                       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}}/books/v1/mylibrary/bookshelves/:shelf" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf",
  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}}/books/v1/mylibrary/bookshelves/:shelf');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/mylibrary/bookshelves/:shelf")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf")

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/books/v1/mylibrary/bookshelves/:shelf') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf";

    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}}/books/v1/mylibrary/bookshelves/:shelf

http GET {{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf")! 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 books.mylibrary.bookshelves.list

{{baseUrl}}/books/v1/mylibrary/bookshelves

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/bookshelves");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/mylibrary/bookshelves")

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves"

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}}/books/v1/mylibrary/bookshelves"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/bookshelves");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/bookshelves"

	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/books/v1/mylibrary/bookshelves HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/mylibrary/bookshelves")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/bookshelves"))
    .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}}/books/v1/mylibrary/bookshelves")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/mylibrary/bookshelves")
  .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}}/books/v1/mylibrary/bookshelves');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves';
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}}/books/v1/mylibrary/bookshelves',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/bookshelves")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/bookshelves',
  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}}/books/v1/mylibrary/bookshelves'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/mylibrary/bookshelves');

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}}/books/v1/mylibrary/bookshelves'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves';
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}}/books/v1/mylibrary/bookshelves"]
                                                       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}}/books/v1/mylibrary/bookshelves" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/mylibrary/bookshelves",
  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}}/books/v1/mylibrary/bookshelves');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/mylibrary/bookshelves")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/bookshelves"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/bookshelves")

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/books/v1/mylibrary/bookshelves') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/mylibrary/bookshelves";

    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}}/books/v1/mylibrary/bookshelves

http GET {{baseUrl}}/books/v1/mylibrary/bookshelves

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/mylibrary/bookshelves

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/bookshelves")! 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()

POST books.mylibrary.bookshelves.moveVolume

{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume

QUERY PARAMS

volumeId

volumePosition

shelf

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume" {:query-params {:volumeId ""
                                                                                                            :volumePosition ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume',
  params: {volumeId: '', volumePosition: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume',
  qs: {volumeId: '', volumePosition: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume');

req.query({
  volumeId: '',
  volumePosition: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume',
  params: {volumeId: '', volumePosition: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'volumeId' => '',
  'volumePosition' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'volumeId' => '',
  'volumePosition' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume"

querystring = {"volumeId":"","volumePosition":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume"

queryString <- list(
  volumeId = "",
  volumePosition = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/books/v1/mylibrary/bookshelves/:shelf/moveVolume') do |req|
  req.params['volumeId'] = ''
  req.params['volumePosition'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume";

    let querystring = [
        ("volumeId", ""),
        ("volumePosition", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition='

http POST '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/moveVolume?volumeId=&volumePosition=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST books.mylibrary.bookshelves.removeVolume

{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume

QUERY PARAMS

volumeId

shelf

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume" {:query-params {:volumeId ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume',
  params: {volumeId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume',
  qs: {volumeId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume');

req.query({
  volumeId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume',
  params: {volumeId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'volumeId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'volumeId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume"

querystring = {"volumeId":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume"

queryString <- list(volumeId = "")

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/books/v1/mylibrary/bookshelves/:shelf/removeVolume') do |req|
  req.params['volumeId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume";

    let querystring = [
        ("volumeId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId='

http POST '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/removeVolume?volumeId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET books.mylibrary.bookshelves.volumes.list

{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes

QUERY PARAMS

shelf

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes")

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes"

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}}/books/v1/mylibrary/bookshelves/:shelf/volumes"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes"

	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/books/v1/mylibrary/bookshelves/:shelf/volumes HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes"))
    .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}}/books/v1/mylibrary/bookshelves/:shelf/volumes")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes")
  .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}}/books/v1/mylibrary/bookshelves/:shelf/volumes');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes';
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}}/books/v1/mylibrary/bookshelves/:shelf/volumes',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/bookshelves/:shelf/volumes',
  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}}/books/v1/mylibrary/bookshelves/:shelf/volumes'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes');

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}}/books/v1/mylibrary/bookshelves/:shelf/volumes'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes';
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}}/books/v1/mylibrary/bookshelves/:shelf/volumes"]
                                                       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}}/books/v1/mylibrary/bookshelves/:shelf/volumes" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes",
  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}}/books/v1/mylibrary/bookshelves/:shelf/volumes');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/mylibrary/bookshelves/:shelf/volumes")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes")

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/books/v1/mylibrary/bookshelves/:shelf/volumes') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes";

    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}}/books/v1/mylibrary/bookshelves/:shelf/volumes

http GET {{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/bookshelves/:shelf/volumes")! 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 books.mylibrary.readingpositions.get

{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId

QUERY PARAMS

volumeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId")

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId"

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}}/books/v1/mylibrary/readingpositions/:volumeId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId"

	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/books/v1/mylibrary/readingpositions/:volumeId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId"))
    .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}}/books/v1/mylibrary/readingpositions/:volumeId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId")
  .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}}/books/v1/mylibrary/readingpositions/:volumeId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId';
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}}/books/v1/mylibrary/readingpositions/:volumeId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/readingpositions/:volumeId',
  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}}/books/v1/mylibrary/readingpositions/:volumeId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId');

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}}/books/v1/mylibrary/readingpositions/:volumeId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId';
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}}/books/v1/mylibrary/readingpositions/:volumeId"]
                                                       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}}/books/v1/mylibrary/readingpositions/:volumeId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId",
  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}}/books/v1/mylibrary/readingpositions/:volumeId');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/mylibrary/readingpositions/:volumeId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId")

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/books/v1/mylibrary/readingpositions/:volumeId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId";

    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}}/books/v1/mylibrary/readingpositions/:volumeId

http GET {{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId")! 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()

POST books.mylibrary.readingpositions.setPosition

{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition

QUERY PARAMS

position

timestamp

volumeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition" {:query-params {:position ""
                                                                                                                     :timestamp ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition',
  params: {position: '', timestamp: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition',
  qs: {position: '', timestamp: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition');

req.query({
  position: '',
  timestamp: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition',
  params: {position: '', timestamp: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'position' => '',
  'timestamp' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'position' => '',
  'timestamp' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition"

querystring = {"position":"","timestamp":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition"

queryString <- list(
  position = "",
  timestamp = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/books/v1/mylibrary/readingpositions/:volumeId/setPosition') do |req|
  req.params['position'] = ''
  req.params['timestamp'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition";

    let querystring = [
        ("position", ""),
        ("timestamp", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp='

http POST '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/mylibrary/readingpositions/:volumeId/setPosition?position=×tamp=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET books.notification.get

{{baseUrl}}/books/v1/notification/get

QUERY PARAMS

notification_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/notification/get?notification_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/notification/get" {:query-params {:notification_id ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/notification/get?notification_id="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/books/v1/notification/get?notification_id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/notification/get?notification_id=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/notification/get?notification_id="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/books/v1/notification/get?notification_id= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/notification/get?notification_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/notification/get?notification_id="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/notification/get?notification_id=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/notification/get?notification_id=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/books/v1/notification/get?notification_id=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/notification/get',
  params: {notification_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/notification/get?notification_id=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/notification/get?notification_id=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/notification/get?notification_id=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/notification/get?notification_id=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/notification/get',
  qs: {notification_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/notification/get');

req.query({
  notification_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/notification/get',
  params: {notification_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/notification/get?notification_id=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/notification/get?notification_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/notification/get?notification_id=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/notification/get?notification_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/books/v1/notification/get?notification_id=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/notification/get');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'notification_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/notification/get');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'notification_id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/notification/get?notification_id=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/notification/get?notification_id=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/notification/get?notification_id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/notification/get"

querystring = {"notification_id":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/notification/get"

queryString <- list(notification_id = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/notification/get?notification_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/books/v1/notification/get') do |req|
  req.params['notification_id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/notification/get";

    let querystring = [
        ("notification_id", ""),
    ];

    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}}/books/v1/notification/get?notification_id='

http GET '{{baseUrl}}/books/v1/notification/get?notification_id='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/books/v1/notification/get?notification_id='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/notification/get?notification_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/onboarding/listCategories");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/onboarding/listCategories")

require "http/client"

url = "{{baseUrl}}/books/v1/onboarding/listCategories"

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}}/books/v1/onboarding/listCategories"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/onboarding/listCategories");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/onboarding/listCategories"

	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/books/v1/onboarding/listCategories HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/onboarding/listCategories")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/onboarding/listCategories"))
    .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}}/books/v1/onboarding/listCategories")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/onboarding/listCategories")
  .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}}/books/v1/onboarding/listCategories');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/onboarding/listCategories'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/onboarding/listCategories';
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}}/books/v1/onboarding/listCategories',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/onboarding/listCategories")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/onboarding/listCategories',
  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}}/books/v1/onboarding/listCategories'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/onboarding/listCategories');

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}}/books/v1/onboarding/listCategories'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/onboarding/listCategories';
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}}/books/v1/onboarding/listCategories"]
                                                       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}}/books/v1/onboarding/listCategories" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/onboarding/listCategories",
  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}}/books/v1/onboarding/listCategories');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/onboarding/listCategories');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/onboarding/listCategories');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/onboarding/listCategories' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/onboarding/listCategories' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/onboarding/listCategories")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/onboarding/listCategories"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/onboarding/listCategories"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/onboarding/listCategories")

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/books/v1/onboarding/listCategories') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/onboarding/listCategories";

    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}}/books/v1/onboarding/listCategories

http GET {{baseUrl}}/books/v1/onboarding/listCategories

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/onboarding/listCategories

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/onboarding/listCategories")! 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 books.onboarding.listCategoryVolumes

{{baseUrl}}/books/v1/onboarding/listCategoryVolumes

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/onboarding/listCategoryVolumes");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/onboarding/listCategoryVolumes")

require "http/client"

url = "{{baseUrl}}/books/v1/onboarding/listCategoryVolumes"

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}}/books/v1/onboarding/listCategoryVolumes"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/onboarding/listCategoryVolumes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/onboarding/listCategoryVolumes"

	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/books/v1/onboarding/listCategoryVolumes HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/onboarding/listCategoryVolumes")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/onboarding/listCategoryVolumes"))
    .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}}/books/v1/onboarding/listCategoryVolumes")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/onboarding/listCategoryVolumes")
  .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}}/books/v1/onboarding/listCategoryVolumes');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/onboarding/listCategoryVolumes'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/onboarding/listCategoryVolumes';
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}}/books/v1/onboarding/listCategoryVolumes',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/onboarding/listCategoryVolumes")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/onboarding/listCategoryVolumes',
  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}}/books/v1/onboarding/listCategoryVolumes'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/onboarding/listCategoryVolumes');

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}}/books/v1/onboarding/listCategoryVolumes'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/onboarding/listCategoryVolumes';
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}}/books/v1/onboarding/listCategoryVolumes"]
                                                       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}}/books/v1/onboarding/listCategoryVolumes" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/onboarding/listCategoryVolumes",
  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}}/books/v1/onboarding/listCategoryVolumes');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/onboarding/listCategoryVolumes');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/onboarding/listCategoryVolumes');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/onboarding/listCategoryVolumes' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/onboarding/listCategoryVolumes' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/onboarding/listCategoryVolumes")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/onboarding/listCategoryVolumes"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/onboarding/listCategoryVolumes"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/onboarding/listCategoryVolumes")

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/books/v1/onboarding/listCategoryVolumes') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/onboarding/listCategoryVolumes";

    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}}/books/v1/onboarding/listCategoryVolumes

http GET {{baseUrl}}/books/v1/onboarding/listCategoryVolumes

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/onboarding/listCategoryVolumes

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/onboarding/listCategoryVolumes")! 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 books.personalizedstream.get

{{baseUrl}}/books/v1/personalizedstream/get

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/personalizedstream/get");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/personalizedstream/get")

require "http/client"

url = "{{baseUrl}}/books/v1/personalizedstream/get"

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}}/books/v1/personalizedstream/get"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/personalizedstream/get");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/personalizedstream/get"

	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/books/v1/personalizedstream/get HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/personalizedstream/get")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/personalizedstream/get"))
    .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}}/books/v1/personalizedstream/get")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/personalizedstream/get")
  .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}}/books/v1/personalizedstream/get');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/personalizedstream/get'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/personalizedstream/get';
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}}/books/v1/personalizedstream/get',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/personalizedstream/get")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/personalizedstream/get',
  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}}/books/v1/personalizedstream/get'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/personalizedstream/get');

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}}/books/v1/personalizedstream/get'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/personalizedstream/get';
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}}/books/v1/personalizedstream/get"]
                                                       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}}/books/v1/personalizedstream/get" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/personalizedstream/get",
  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}}/books/v1/personalizedstream/get');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/personalizedstream/get');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/personalizedstream/get');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/personalizedstream/get' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/personalizedstream/get' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/personalizedstream/get")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/personalizedstream/get"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/personalizedstream/get"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/personalizedstream/get")

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/books/v1/personalizedstream/get') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/personalizedstream/get";

    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}}/books/v1/personalizedstream/get

http GET {{baseUrl}}/books/v1/personalizedstream/get

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/personalizedstream/get

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/personalizedstream/get")! 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()

POST books.promooffer.accept

{{baseUrl}}/books/v1/promooffer/accept

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/promooffer/accept");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/books/v1/promooffer/accept")

require "http/client"

url = "{{baseUrl}}/books/v1/promooffer/accept"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/promooffer/accept"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/promooffer/accept");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/promooffer/accept"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/books/v1/promooffer/accept HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/promooffer/accept")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/promooffer/accept"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/promooffer/accept")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/promooffer/accept")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/books/v1/promooffer/accept');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/books/v1/promooffer/accept'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/promooffer/accept';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/promooffer/accept',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/promooffer/accept")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/promooffer/accept',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/books/v1/promooffer/accept'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/promooffer/accept');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/books/v1/promooffer/accept'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/promooffer/accept';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/promooffer/accept"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/promooffer/accept" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/promooffer/accept",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/books/v1/promooffer/accept');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/promooffer/accept');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/promooffer/accept');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/promooffer/accept' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/promooffer/accept' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/books/v1/promooffer/accept")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/promooffer/accept"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/promooffer/accept"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/promooffer/accept")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/books/v1/promooffer/accept') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/promooffer/accept";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/books/v1/promooffer/accept

http POST {{baseUrl}}/books/v1/promooffer/accept

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/books/v1/promooffer/accept

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/promooffer/accept")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST books.promooffer.dismiss

{{baseUrl}}/books/v1/promooffer/dismiss

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/promooffer/dismiss");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/books/v1/promooffer/dismiss")

require "http/client"

url = "{{baseUrl}}/books/v1/promooffer/dismiss"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/promooffer/dismiss"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/promooffer/dismiss");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/promooffer/dismiss"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/books/v1/promooffer/dismiss HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/promooffer/dismiss")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/promooffer/dismiss"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/promooffer/dismiss")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/promooffer/dismiss")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/books/v1/promooffer/dismiss');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/books/v1/promooffer/dismiss'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/promooffer/dismiss';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/promooffer/dismiss',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/promooffer/dismiss")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/promooffer/dismiss',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/books/v1/promooffer/dismiss'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/promooffer/dismiss');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/books/v1/promooffer/dismiss'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/promooffer/dismiss';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/promooffer/dismiss"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/promooffer/dismiss" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/promooffer/dismiss",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/books/v1/promooffer/dismiss');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/promooffer/dismiss');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/promooffer/dismiss');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/promooffer/dismiss' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/promooffer/dismiss' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/books/v1/promooffer/dismiss")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/promooffer/dismiss"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/promooffer/dismiss"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/promooffer/dismiss")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/books/v1/promooffer/dismiss') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/promooffer/dismiss";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/books/v1/promooffer/dismiss

http POST {{baseUrl}}/books/v1/promooffer/dismiss

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/books/v1/promooffer/dismiss

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/promooffer/dismiss")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET books.promooffer.get

{{baseUrl}}/books/v1/promooffer/get

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/promooffer/get");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/promooffer/get")

require "http/client"

url = "{{baseUrl}}/books/v1/promooffer/get"

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}}/books/v1/promooffer/get"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/promooffer/get");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/promooffer/get"

	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/books/v1/promooffer/get HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/promooffer/get")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/promooffer/get"))
    .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}}/books/v1/promooffer/get")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/promooffer/get")
  .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}}/books/v1/promooffer/get');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/books/v1/promooffer/get'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/promooffer/get';
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}}/books/v1/promooffer/get',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/promooffer/get")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/promooffer/get',
  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}}/books/v1/promooffer/get'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/promooffer/get');

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}}/books/v1/promooffer/get'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/promooffer/get';
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}}/books/v1/promooffer/get"]
                                                       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}}/books/v1/promooffer/get" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/promooffer/get",
  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}}/books/v1/promooffer/get');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/promooffer/get');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/promooffer/get');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/promooffer/get' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/promooffer/get' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/promooffer/get")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/promooffer/get"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/promooffer/get"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/promooffer/get")

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/books/v1/promooffer/get') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/promooffer/get";

    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}}/books/v1/promooffer/get

http GET {{baseUrl}}/books/v1/promooffer/get

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/promooffer/get

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/promooffer/get")! 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 books.series.get

{{baseUrl}}/books/v1/series/get

QUERY PARAMS

series_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/series/get?series_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/series/get" {:query-params {:series_id ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/series/get?series_id="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/books/v1/series/get?series_id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/series/get?series_id=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/series/get?series_id="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/books/v1/series/get?series_id= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/series/get?series_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/series/get?series_id="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/series/get?series_id=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/series/get?series_id=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/books/v1/series/get?series_id=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/series/get',
  params: {series_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/series/get?series_id=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/series/get?series_id=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/series/get?series_id=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/series/get?series_id=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/series/get',
  qs: {series_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/series/get');

req.query({
  series_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/series/get',
  params: {series_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/series/get?series_id=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/series/get?series_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/series/get?series_id=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/series/get?series_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/books/v1/series/get?series_id=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/series/get');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'series_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/series/get');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'series_id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/series/get?series_id=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/series/get?series_id=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/series/get?series_id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/series/get"

querystring = {"series_id":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/series/get"

queryString <- list(series_id = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/series/get?series_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/books/v1/series/get') do |req|
  req.params['series_id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/series/get";

    let querystring = [
        ("series_id", ""),
    ];

    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}}/books/v1/series/get?series_id='

http GET '{{baseUrl}}/books/v1/series/get?series_id='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/books/v1/series/get?series_id='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/series/get?series_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET books.series.membership.get

{{baseUrl}}/books/v1/series/membership/get

QUERY PARAMS

series_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/series/membership/get?series_id=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/series/membership/get" {:query-params {:series_id ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/series/membership/get?series_id="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/books/v1/series/membership/get?series_id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/series/membership/get?series_id=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/series/membership/get?series_id="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/books/v1/series/membership/get?series_id= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/series/membership/get?series_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/series/membership/get?series_id="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/series/membership/get?series_id=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/series/membership/get?series_id=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/books/v1/series/membership/get?series_id=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/series/membership/get',
  params: {series_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/series/membership/get?series_id=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/series/membership/get?series_id=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/series/membership/get?series_id=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/series/membership/get?series_id=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/series/membership/get',
  qs: {series_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/series/membership/get');

req.query({
  series_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/series/membership/get',
  params: {series_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/series/membership/get?series_id=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/series/membership/get?series_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/series/membership/get?series_id=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/series/membership/get?series_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/books/v1/series/membership/get?series_id=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/series/membership/get');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'series_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/series/membership/get');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'series_id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/series/membership/get?series_id=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/series/membership/get?series_id=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/series/membership/get?series_id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/series/membership/get"

querystring = {"series_id":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/series/membership/get"

queryString <- list(series_id = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/series/membership/get?series_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/books/v1/series/membership/get') do |req|
  req.params['series_id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/series/membership/get";

    let querystring = [
        ("series_id", ""),
    ];

    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}}/books/v1/series/membership/get?series_id='

http GET '{{baseUrl}}/books/v1/series/membership/get?series_id='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/books/v1/series/membership/get?series_id='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/series/membership/get?series_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET books.volumes.associated.list

{{baseUrl}}/books/v1/volumes/:volumeId/associated

QUERY PARAMS

volumeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes/:volumeId/associated");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/volumes/:volumeId/associated")

require "http/client"

url = "{{baseUrl}}/books/v1/volumes/:volumeId/associated"

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}}/books/v1/volumes/:volumeId/associated"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/volumes/:volumeId/associated");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/volumes/:volumeId/associated"

	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/books/v1/volumes/:volumeId/associated HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/volumes/:volumeId/associated")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes/:volumeId/associated"))
    .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}}/books/v1/volumes/:volumeId/associated")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/volumes/:volumeId/associated")
  .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}}/books/v1/volumes/:volumeId/associated');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/volumes/:volumeId/associated'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/associated';
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}}/books/v1/volumes/:volumeId/associated',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/:volumeId/associated")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/volumes/:volumeId/associated',
  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}}/books/v1/volumes/:volumeId/associated'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/volumes/:volumeId/associated');

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}}/books/v1/volumes/:volumeId/associated'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/volumes/:volumeId/associated';
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}}/books/v1/volumes/:volumeId/associated"]
                                                       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}}/books/v1/volumes/:volumeId/associated" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/volumes/:volumeId/associated",
  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}}/books/v1/volumes/:volumeId/associated');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes/:volumeId/associated');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/volumes/:volumeId/associated');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/associated' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes/:volumeId/associated' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/volumes/:volumeId/associated")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/volumes/:volumeId/associated"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes/:volumeId/associated"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes/:volumeId/associated")

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/books/v1/volumes/:volumeId/associated') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes/:volumeId/associated";

    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}}/books/v1/volumes/:volumeId/associated

http GET {{baseUrl}}/books/v1/volumes/:volumeId/associated

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/volumes/:volumeId/associated

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes/:volumeId/associated")! 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 books.volumes.get

{{baseUrl}}/books/v1/volumes/:volumeId

QUERY PARAMS

volumeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes/:volumeId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/volumes/:volumeId")

require "http/client"

url = "{{baseUrl}}/books/v1/volumes/:volumeId"

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}}/books/v1/volumes/:volumeId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/volumes/:volumeId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/volumes/:volumeId"

	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/books/v1/volumes/:volumeId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/volumes/:volumeId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes/:volumeId"))
    .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}}/books/v1/volumes/:volumeId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/volumes/:volumeId")
  .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}}/books/v1/volumes/:volumeId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/books/v1/volumes/:volumeId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/volumes/:volumeId';
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}}/books/v1/volumes/:volumeId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/:volumeId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/volumes/:volumeId',
  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}}/books/v1/volumes/:volumeId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/volumes/:volumeId');

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}}/books/v1/volumes/:volumeId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/volumes/:volumeId';
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}}/books/v1/volumes/:volumeId"]
                                                       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}}/books/v1/volumes/:volumeId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/volumes/:volumeId",
  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}}/books/v1/volumes/:volumeId');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes/:volumeId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/volumes/:volumeId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes/:volumeId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes/:volumeId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/volumes/:volumeId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/volumes/:volumeId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes/:volumeId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes/:volumeId")

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/books/v1/volumes/:volumeId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes/:volumeId";

    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}}/books/v1/volumes/:volumeId

http GET {{baseUrl}}/books/v1/volumes/:volumeId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/volumes/:volumeId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes/:volumeId")! 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 books.volumes.list

{{baseUrl}}/books/v1/volumes

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes?q=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/volumes" {:query-params {:q ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/volumes?q="

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}}/books/v1/volumes?q="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/volumes?q=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/volumes?q="

	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/books/v1/volumes?q= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/volumes?q=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes?q="))
    .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}}/books/v1/volumes?q=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/volumes?q=")
  .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}}/books/v1/volumes?q=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/volumes',
  params: {q: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/volumes?q=';
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}}/books/v1/volumes?q=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes?q=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/volumes?q=',
  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}}/books/v1/volumes',
  qs: {q: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/volumes');

req.query({
  q: ''
});

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}}/books/v1/volumes',
  params: {q: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/volumes?q=';
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}}/books/v1/volumes?q="]
                                                       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}}/books/v1/volumes?q=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/volumes?q=",
  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}}/books/v1/volumes?q=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'q' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/volumes');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'q' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes?q=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes?q=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/volumes?q=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/volumes"

querystring = {"q":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes"

queryString <- list(q = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes?q=")

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/books/v1/volumes') do |req|
  req.params['q'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes";

    let querystring = [
        ("q", ""),
    ];

    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}}/books/v1/volumes?q='

http GET '{{baseUrl}}/books/v1/volumes?q='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/books/v1/volumes?q='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes?q=")! 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 books.volumes.mybooks.list

{{baseUrl}}/books/v1/volumes/mybooks

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes/mybooks");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/volumes/mybooks")

require "http/client"

url = "{{baseUrl}}/books/v1/volumes/mybooks"

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}}/books/v1/volumes/mybooks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/volumes/mybooks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/volumes/mybooks"

	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/books/v1/volumes/mybooks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/volumes/mybooks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes/mybooks"))
    .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}}/books/v1/volumes/mybooks")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/volumes/mybooks")
  .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}}/books/v1/volumes/mybooks');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/books/v1/volumes/mybooks'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/volumes/mybooks';
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}}/books/v1/volumes/mybooks',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/mybooks")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/volumes/mybooks',
  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}}/books/v1/volumes/mybooks'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/volumes/mybooks');

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}}/books/v1/volumes/mybooks'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/volumes/mybooks';
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}}/books/v1/volumes/mybooks"]
                                                       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}}/books/v1/volumes/mybooks" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/volumes/mybooks",
  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}}/books/v1/volumes/mybooks');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes/mybooks');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/volumes/mybooks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes/mybooks' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes/mybooks' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/volumes/mybooks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/volumes/mybooks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes/mybooks"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes/mybooks")

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/books/v1/volumes/mybooks') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes/mybooks";

    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}}/books/v1/volumes/mybooks

http GET {{baseUrl}}/books/v1/volumes/mybooks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/volumes/mybooks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes/mybooks")! 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 books.volumes.recommended.list

{{baseUrl}}/books/v1/volumes/recommended

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes/recommended");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/volumes/recommended")

require "http/client"

url = "{{baseUrl}}/books/v1/volumes/recommended"

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}}/books/v1/volumes/recommended"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/volumes/recommended");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/volumes/recommended"

	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/books/v1/volumes/recommended HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/volumes/recommended")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes/recommended"))
    .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}}/books/v1/volumes/recommended")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/volumes/recommended")
  .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}}/books/v1/volumes/recommended');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/books/v1/volumes/recommended'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/volumes/recommended';
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}}/books/v1/volumes/recommended',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/recommended")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/volumes/recommended',
  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}}/books/v1/volumes/recommended'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/volumes/recommended');

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}}/books/v1/volumes/recommended'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/volumes/recommended';
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}}/books/v1/volumes/recommended"]
                                                       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}}/books/v1/volumes/recommended" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/volumes/recommended",
  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}}/books/v1/volumes/recommended');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes/recommended');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/volumes/recommended');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes/recommended' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes/recommended' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/volumes/recommended")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/volumes/recommended"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes/recommended"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes/recommended")

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/books/v1/volumes/recommended') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes/recommended";

    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}}/books/v1/volumes/recommended

http GET {{baseUrl}}/books/v1/volumes/recommended

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/volumes/recommended

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes/recommended")! 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()

POST books.volumes.recommended.rate

{{baseUrl}}/books/v1/volumes/recommended/rate

QUERY PARAMS

rating

volumeId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/books/v1/volumes/recommended/rate" {:query-params {:rating ""
                                                                                             :volumeId ""}})

require "http/client"

url = "{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/books/v1/volumes/recommended/rate?rating=&volumeId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/volumes/recommended/rate',
  params: {rating: '', volumeId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/volumes/recommended/rate?rating=&volumeId=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/volumes/recommended/rate',
  qs: {rating: '', volumeId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/books/v1/volumes/recommended/rate');

req.query({
  rating: '',
  volumeId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/books/v1/volumes/recommended/rate',
  params: {rating: '', volumeId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes/recommended/rate');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'rating' => '',
  'volumeId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/volumes/recommended/rate');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'rating' => '',
  'volumeId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/books/v1/volumes/recommended/rate?rating=&volumeId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/volumes/recommended/rate"

querystring = {"rating":"","volumeId":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes/recommended/rate"

queryString <- list(
  rating = "",
  volumeId = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/books/v1/volumes/recommended/rate') do |req|
  req.params['rating'] = ''
  req.params['volumeId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes/recommended/rate";

    let querystring = [
        ("rating", ""),
        ("volumeId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId='

http POST '{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes/recommended/rate?rating=&volumeId=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET books.volumes.useruploaded.list

{{baseUrl}}/books/v1/volumes/useruploaded

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/books/v1/volumes/useruploaded");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/books/v1/volumes/useruploaded")

require "http/client"

url = "{{baseUrl}}/books/v1/volumes/useruploaded"

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}}/books/v1/volumes/useruploaded"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/books/v1/volumes/useruploaded");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/books/v1/volumes/useruploaded"

	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/books/v1/volumes/useruploaded HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/books/v1/volumes/useruploaded")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/books/v1/volumes/useruploaded"))
    .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}}/books/v1/volumes/useruploaded")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/books/v1/volumes/useruploaded")
  .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}}/books/v1/volumes/useruploaded');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/books/v1/volumes/useruploaded'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/books/v1/volumes/useruploaded';
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}}/books/v1/volumes/useruploaded',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/books/v1/volumes/useruploaded")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/books/v1/volumes/useruploaded',
  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}}/books/v1/volumes/useruploaded'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/books/v1/volumes/useruploaded');

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}}/books/v1/volumes/useruploaded'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/books/v1/volumes/useruploaded';
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}}/books/v1/volumes/useruploaded"]
                                                       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}}/books/v1/volumes/useruploaded" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/books/v1/volumes/useruploaded",
  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}}/books/v1/volumes/useruploaded');

echo $response->getBody();

setUrl('{{baseUrl}}/books/v1/volumes/useruploaded');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/books/v1/volumes/useruploaded');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/books/v1/volumes/useruploaded' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/books/v1/volumes/useruploaded' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/books/v1/volumes/useruploaded")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/books/v1/volumes/useruploaded"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/books/v1/volumes/useruploaded"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/books/v1/volumes/useruploaded")

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/books/v1/volumes/useruploaded') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/books/v1/volumes/useruploaded";

    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}}/books/v1/volumes/useruploaded

http GET {{baseUrl}}/books/v1/volumes/useruploaded

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/books/v1/volumes/useruploaded

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/books/v1/volumes/useruploaded")! 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()