@health-samurai/aidbox-client 0.0.0-alpha.2 → 0.0.0-alpha.3

package/dist/src/client.js

@@ -35,6 +35,40 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -208,967 +242,1454 @@ var makeUrl = function(parts) {
     }).join("/"));
 };
 var basePath = "fhir";
+var _internalRawRequest = /*#__PURE__*/ new WeakSet();
+/// IMPORTANT:
+///
+/// PLEASE, use one sentence per line approach in the docstrings.
+/// Don't use hard-wrapping, it makes git-diff a painfull experience.
 /**
  * Create a client to the FHIR server.
  *
  * ```typescript
+ * import type { User } from "@health-samurai/aidbox-client";
+ *
  * const baseUrl = "https://fhir-server.address";
- * const client = makeClient({
+ * const client = new AidboxClient(
  *   baseUrl,
- *   authProvider: new BrowserAuthProvider(baseUrl);
- * });
+ *   new BrowserAuthProvider(baseUrl);
+ * );
  *
  * // alternatively, specify different FHIR types:
  * import type { Bundle, OperationOutcome } from "hl7-fhir-r5-core";
- * const client = makeClient<Bundle, OperationOutcome, User>({
+ * const client = new AidboxClient<Bundle, OperationOutcome, User>(
  *   baseUrl,
  *   authProvider: new BrowserAuthProvider(baseUrl);
- * });
+ * );
  * ```
  *
  * Main client functions are `request` for typed interactions, and `rawRequest` for manual response processing.
  *
- * This client also provides a set of convenience methods for accessing FHIR operations:
+ * This client also provides a set of convenience methods for accessing FHIR operations, provided below.
  *
- * - `read`
- * - `vread`
- * - `searchType`
- * - `searchSystem`
- * - `searchCompartment`
- * - `create`
- * - `conditionalCreate`
- * - `update`
- * - `conditionalUpdate`
- * - `patch`
- * - `conditionalPatch`
- * - `delete: deleteOp`
- * - `deleteHistory`
- * - `deleteHistoryVersion`
- * - `conditionalDelete`
- * - `historyInstance`
- * - `historyType`
- * - `historySystem`
- * - `capabilities`
- * - `batch`
- * - `transaction`
- * - `operation`
- * - `validate`
- */ export function makeClient(param) {
-    var baseUrl = param.baseUrl, authProvider = param.authProvider;
-    var getBaseUrl = function() {
-        return baseUrl;
-    };
-    // TODO: async response pattern
-    var internalRawRequest = function(requestParams) {
-        return _async_to_generator(function() {
-            var startTime, baseUrl, method, url, _requestParams_headers, headers, _requestParams_params, params, body, urlObj, requestHeaders, request, response, responseHeaders, e;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        startTime = performance.now();
-                        baseUrl = getBaseUrl();
-                        if (!requestParams.url.startsWith("/")) return [
-                            2,
-                            {
-                                error: new RequestError("URL must start with a forward slash", {
-                                    request: requestParams
-                                }),
-                                duration: performance.now() - startTime,
-                                request: requestParams
-                            }
-                        ];
-                        method = requestParams.method, url = requestParams.url, _requestParams_headers = requestParams.headers, headers = _requestParams_headers === void 0 ? {} : _requestParams_headers, _requestParams_params = requestParams.params, params = _requestParams_params === void 0 ? [] : _requestParams_params, body = requestParams.body;
-                        urlObj = new URL(url, baseUrl);
-                        params.forEach(function(param) {
-                            var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
-                            urlObj.searchParams.append(key, value);
-                        });
-                        requestHeaders = {
-                            "content-type": "application/json",
-                            accept: "application/json"
-                        };
-                        Object.entries(headers).forEach(function(param) {
-                            var _param = _sliced_to_array(param, 2), header = _param[0], value = _param[1];
-                            requestHeaders[header.toLowerCase()] = value;
-                        });
-                        request = {
-                            method: method,
-                            url: url,
-                            params: params,
-                            headers: requestHeaders,
-                            body: body !== null && body !== void 0 ? body : ""
-                        };
-                        _state.label = 1;
-                    case 1:
-                        _state.trys.push([
-                            1,
-                            3,
-                            ,
-                            4
-                        ]);
-                        return [
-                            4,
-                            authProvider.fetch(urlObj.toString(), {
-                                method: method,
-                                headers: requestHeaders,
-                                body: body || null,
-                                cache: "no-store"
-                            })
-                        ];
-                    case 2:
-                        response = _state.sent();
-                        responseHeaders = {};
-                        response.headers.forEach(function(value, key) {
-                            responseHeaders[key] = value;
-                        });
-                        return [
-                            2,
-                            {
-                                response: response,
-                                responseHeaders: responseHeaders,
-                                duration: performance.now() - startTime,
-                                request: request
-                            }
-                        ];
-                    case 3:
-                        e = _state.sent();
-                        return [
-                            2,
-                            {
-                                error: new RequestError(e && (typeof e === "undefined" ? "undefined" : _type_of(e)) === "object" && "message" in e ? "error during request: ".concat(e.message) : "unknown error during request", {
-                                    cause: e,
-                                    request: request
-                                }),
-                                duration: performance.now() - startTime,
-                                request: request
-                            }
-                        ];
-                    case 4:
-                        return [
-                            2
-                        ];
-                }
-            });
-        })();
-    };
-    var rawRequest = function(requestParams) {
-        return _async_to_generator(function() {
-            var result;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            internalRawRequest(requestParams)
-                        ];
-                    case 1:
-                        result = _state.sent();
-                        if (isInternalErrorResponse(result)) throw result.error;
-                        if (!result.response.ok) throw new ErrorResponse("HTTP ".concat(result.response.status, ": ").concat(result.response.statusText), result);
-                        return [
-                            2,
-                            result
-                        ];
-                }
-            });
-        })();
-    };
-    var request = function(params) {
-        return _async_to_generator(function() {
-            var response, body;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            internalRawRequest(params)
-                        ];
-                    case 1:
-                        response = _state.sent();
-                        if (isInternalErrorResponse(response)) throw response.error;
-                        return [
-                            4,
-                            coerceBody(response)
-                        ];
-                    case 2:
-                        body = _state.sent();
-                        if (!response.response.ok) {
-                            if (body.resourceType === "OperationOutcome") return [
-                                2,
-                                Err(_object_spread({
-                                    resource: body
-                                }, response))
-                            ];
-                            throw new ErrorResponse("HTTP ".concat(response.response.status, ": ").concat(response.response.statusText), response);
+ * @showGroups
+ */ export var AidboxClient = /*#__PURE__*/ function() {
+    "use strict";
+    function AidboxClient(baseUrl, authProvider) {
+        _class_call_check(this, AidboxClient);
+        // TODO: async response pattern
+        _class_private_method_init(this, _internalRawRequest);
+        _define_property(this, "baseUrl", void 0);
+        _define_property(this, "authProvider", void 0);
+        this.baseUrl = baseUrl;
+        this.authProvider = authProvider;
+    }
+    _create_class(AidboxClient, [
+        {
+            key: "read",
+            value: /// FHIR HTTP methods
+            /**
+	 *
+	 * Read the current state of the resource
+	 *
+	 * The interaction is performed by an HTTP GET command as shown:
+	 *
+	 * ```
+	 * GET [base]/[type]/[id] {?_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#read
+	 *
+	 * Example usage:
+	 *
+	 * ```typescript
+	 * const patient = await client.read<Patient>({
+	 *   type: "Patient",
+	 *   id: "patient-id",
+	 * });
+	 * ```
+	 *
+	 * @group Instance Level Interactions
+	 */ function read(opts) {
+                return _async_to_generator(function() {
+                    var requestParams;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                requestParams = {
+                                    url: makeUrl([
+                                        basePath,
+                                        opts.type,
+                                        opts.id
+                                    ]),
+                                    method: "GET"
+                                };
+                                if (opts.mimeType) requestParams.headers = {
+                                    accept: opts.mimeType
+                                };
+                                return [
+                                    4,
+                                    this.request(requestParams)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
                         }
-                        return [
-                            2,
-                            Ok(_object_spread({
-                                resource: body
-                            }, response))
-                        ];
-                }
-            });
-        })();
-    };
-    var fetchUserInfo = function() {
-        return _async_to_generator(function() {
-            var user;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            rawRequest({
-                                url: "/auth/userinfo",
-                                method: "GET",
-                                headers: {
-                                    "Content-Type": "application/json",
-                                    Accept: "application/json"
-                                }
-                            }).then(function(response) {
-                                return coerceBody(response);
-                            })
-                        ];
-                    case 1:
-                        user = _state.sent();
-                        return [
-                            2,
-                            user
-                        ];
-                }
-            });
-        })();
-    };
-    var performLogout = function() {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            rawRequest({
-                                url: "/auth/logout",
-                                method: "POST",
-                                headers: {
-                                    "Content-Type": "application/json",
-                                    Accept: "application/json"
-                                }
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent().response
-                        ];
-                }
-            });
-        })();
-    };
-    /// FHIR HTTP methods
-    var read = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
-                                    basePath,
-                                    opts.type,
-                                    opts.id
-                                ]),
-                                method: "GET"
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var vread = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
-                                    basePath,
-                                    opts.type,
-                                    opts.id,
-                                    "_history",
-                                    opts.vid
-                                ]),
-                                method: "GET"
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var searchType = function(opts) {
-        return _async_to_generator(function() {
-            var url, requestParams;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        url = [
-                            basePath,
-                            opts.type
-                        ];
-                        requestParams = {
-                            url: makeUrl(url),
-                            method: "GET",
-                            headers: {
-                                "Content-Type": "application/x-www-form-urlencoded"
-                            },
-                            params: opts.query
-                        };
-                        return [
-                            4,
-                            request(requestParams)
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var searchSystem = function(opts) {
-        return _async_to_generator(function() {
-            var url, requestParams;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        url = [
-                            basePath
-                        ];
-                        requestParams = {
-                            url: makeUrl(url),
-                            method: "GET",
-                            headers: {
-                                "Content-Type": "application/x-www-form-urlencoded"
-                            },
-                            params: opts.query
-                        };
-                        return [
-                            4,
-                            request(requestParams)
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var searchCompartment = function(opts) {
-        return _async_to_generator(function() {
-            var url, requestParams;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        url = [
-                            basePath,
-                            opts.compartment,
-                            opts.compartmentId,
-                            opts.type
-                        ];
-                        requestParams = {
-                            url: makeUrl(url),
-                            method: "GET",
-                            headers: {
-                                "Content-Type": "application/x-www-form-urlencoded"
-                            },
-                            params: opts.query
-                        };
-                        return [
-                            4,
-                            request(requestParams)
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var create = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
-                                    basePath,
-                                    opts.type
-                                ]),
-                                method: "POST",
-                                body: JSON.stringify(opts.resource)
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var conditionalCreate = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
-                                    basePath,
-                                    opts.type
-                                ]),
-                                method: "POST",
-                                headers: {
-                                    "If-None-Exist": new URLSearchParams(opts.searchParameters).toString()
-                                },
-                                body: JSON.stringify(opts.resource)
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var update = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
-                                    basePath,
-                                    opts.type,
-                                    opts.id
-                                ]),
-                                method: "PUT",
-                                body: JSON.stringify(opts.resource)
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var conditionalUpdate = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "vread",
+            value: /**
+	 * Read the state of a specific version of the resource
+	 *
+	 * The interaction is performed by an HTTP GET command as shown:
+	 *
+	 * ```
+	 * GET [base]/[type]/[id]/_history/[vid] {?_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#vread
+	 *
+	 * Example usage:
+	 *
+	 * ```typescript
+	 * const patient = await client.vread<Patient>({
+	 *   type: "Patient",
+	 *   id: "patient-id",
+	 *   vid: "version-id",
+	 * });
+	 * ```
+	 *
+	 * @group Instance Level Interactions
+	 */ function vread(opts) {
+                return _async_to_generator(function() {
+                    var requestParams;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                requestParams = {
+                                    url: makeUrl([
+                                        basePath,
+                                        opts.type,
+                                        opts.id,
+                                        "_history",
+                                        opts.vid
+                                    ]),
+                                    method: "GET"
+                                };
+                                if (opts.mimeType) requestParams.headers = {
+                                    accept: opts.mimeType
+                                };
+                                return [
+                                    4,
+                                    this.request(requestParams)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "searchType",
+            value: /**
+	 * Search the resource type based on some filter criteria.
+	 *
+	 * The interaction is performed by an HTTP GET command as shown:
+	 *
+	 * ```
+	 * GET [base]/[resource-type]/?param1=value&...{&_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#search-get
+	 *
+	 * Example usage:
+	 *
+	 * ```typescript
+	 * const searchset: Bundle = await client.searchType({
+	 *   type: "Patient",
+	 *   query: [["family", "Unknown"]],
+	 * });
+	 * ```
+	 *
+	 * @group Type Level Interactions
+	 */ function searchType(opts) {
+                return _async_to_generator(function() {
+                    var url, requestParams;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                url = [
                                     basePath,
                                     opts.type
-                                ]),
-                                method: "PUT",
-                                body: JSON.stringify(opts.resource),
-                                params: opts.searchParameters
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var patch = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
-                                    basePath,
-                                    opts.type,
-                                    opts.id
-                                ]),
-                                method: "PATCH",
-                                headers: {
-                                    "Content-Type": "application/json-patch+json"
-                                },
-                                body: JSON.stringify(opts.patch)
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var conditionalPatch = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
+                                ];
+                                requestParams = {
+                                    url: makeUrl(url),
+                                    method: "GET",
+                                    headers: {
+                                        "Content-Type": "application/x-www-form-urlencoded"
+                                    },
+                                    params: opts.query
+                                };
+                                return [
+                                    4,
+                                    this.request(requestParams)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "searchSystem",
+            value: /**
+	 * Search the system based on some filter criteria.
+	 *
+	 * The interaction is performed by an HTTP GET command as shown:
+	 *
+	 * ```
+	 * GET [base]?param1=value&...{&_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#search-get
+	 *
+	 * Example usage:
+	 *
+	 * ```typescript
+	 * const searchset: Bundle = await client.searchSystem({
+	 *   query: [["family", "Unknown"]]
+	 * });
+	 * ```
+	 *
+	 * @group Whole System Interactions
+	 */ function searchSystem(opts) {
+                return _async_to_generator(function() {
+                    var url, requestParams;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                url = [
+                                    basePath
+                                ];
+                                requestParams = {
+                                    url: makeUrl(url),
+                                    method: "GET",
+                                    headers: {
+                                        "Content-Type": "application/x-www-form-urlencoded"
+                                    },
+                                    params: opts.query
+                                };
+                                return [
+                                    4,
+                                    this.request(requestParams)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "searchCompartment",
+            value: /**
+	 * Search the resource type across the compartment based on some filter criteria.
+	 *
+	 * The interaction is performed by an HTTP GET command as shown:
+	 *
+	 * ```
+	 * GET [base]/[compartment-type]/[compartment-id]/[resource-type]?param1=value&...{&_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#search-get
+	 *
+	 * Example usage:
+	 *
+	 * ```typescript
+	 * const result: Bundle = await client.searchCompartment({
+	 *   compartment: "Patient",
+	 *   compartmentId: "patient-id",
+	 *   type: "Observation",
+	 *   query: [["status", "final"]],
+	 * });
+	 * ```
+	 *
+	 * @group Compartment Interactions
+	 */ function searchCompartment(opts) {
+                return _async_to_generator(function() {
+                    var url, requestParams;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                url = [
                                     basePath,
+                                    opts.compartment,
+                                    opts.compartmentId,
                                     opts.type
-                                ]),
-                                method: "PATCH",
-                                headers: {
-                                    "Content-Type": "application/json-patch+json"
-                                },
-                                params: opts.searchParameters,
-                                body: JSON.stringify(opts.patch)
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var deleteOp = function(opts) {
-        return _async_to_generator(function() {
-            var response, body;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            internalRawRequest({
-                                url: makeUrl([
-                                    basePath,
-                                    opts.type,
-                                    opts.id
-                                ]),
-                                method: "DELETE"
-                            })
-                        ];
-                    case 1:
-                        response = _state.sent();
-                        if (isInternalErrorResponse(response)) throw response.error;
-                        if (response.response.status === 204) return [
-                            2,
-                            Ok(_object_spread({
-                                resource: undefined
-                            }, response))
-                        ];
-                        return [
-                            4,
-                            coerceBody(response)
-                        ];
-                    case 2:
-                        body = _state.sent();
-                        if (!response.response.ok) {
-                            if (body.resourceType === "OperationOutcome") return [
-                                2,
-                                Err(_object_spread({
-                                    resource: body
-                                }, response))
-                            ];
-                            throw new ErrorResponse("HTTP ".concat(response.response.status, ": ").concat(response.response.statusText), response);
+                                ];
+                                requestParams = {
+                                    url: makeUrl(url),
+                                    method: "GET",
+                                    headers: {
+                                        "Content-Type": "application/x-www-form-urlencoded"
+                                    },
+                                    params: opts.query
+                                };
+                                return [
+                                    4,
+                                    this.request(requestParams)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
                         }
-                        return [
-                            2,
-                            Ok(_object_spread({
-                                resource: body
-                            }, response))
-                        ];
-                }
-            });
-        })();
-    };
-    var deleteHistory = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "create",
+            value: /**
+	 * Create a new resource with a server assigned id.
+	 *
+	 * The `create` interaction is performed by an HTTP POST command as shown:
+	 *
+	 * ```
+	 * POST [base]/[type] {?_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#create
+	 *
+	 * Example usage:
+	 *
+	 * ```typescript
+	 * const patient = await client.create<Patient>({
+	 *   type: "Patient",
+	 *   resource: {
+	 *     id: "patient-id",
+	 *     name: [{
+	 *       family: "Test",
+	 *       given: ["Patient"],
+	 *     }],
+	 *   },
+	 * });
+	 * ```
+	 *
+	 * @group Type Level Interactions
+	 */ function create(opts) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        url: makeUrl([
+                                            basePath,
+                                            opts.type
+                                        ]),
+                                        method: "POST",
+                                        body: JSON.stringify(opts.resource)
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "conditionalCreate",
+            value: /**
+	 * The conditional create interaction allows a client to create a new resource only if some equivalent resource does not already exist on the server.
+	 * The client defines what equivalence means in this case by supplying a FHIR search query using an HL7 defined extension header `If-None-Exist`.
+	 *
+	 * The conditional `create` interaction is performed by an HTTP POST command as shown:
+	 *
+	 * ```
+	 * POST [base]/[type]?param1=value&...{&_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#ccreate
+	 *
+	 * @group Type Level Interactions
+	 */ function conditionalCreate(opts) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        url: makeUrl([
+                                            basePath,
+                                            opts.type
+                                        ]),
+                                        method: "POST",
+                                        headers: {
+                                            "If-None-Exist": new URLSearchParams(opts.searchParameters).toString()
+                                        },
+                                        body: JSON.stringify(opts.resource)
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "update",
+            value: /**
+	 * Update an existing resource by its id (or create it if it is new)
+	 *
+	 * The `update` interaction is performed by an HTTP PUT command as shown:
+	 *
+	 * ```
+	 * PUT [base]/[type]/[id] {?_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#update
+	 *
+	 * Example usage:
+	 *
+	 * ```typescript
+	 * const result = await client.update<Patient>({
+	 *   type: "Patient",
+	 *   id: patientId,
+	 *   resource: {
+	 *     resourceType: "Patient",
+	 *     name: [{
+	 *       family: "Smith",
+	 *       given: ["John"],
+	 *     }],
+	 *   },
+	 * });
+	 * ```
+	 *
+	 * @group Instance Level Interactions
+	 */ function update(opts) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        url: makeUrl([
+                                            basePath,
+                                            opts.type,
+                                            opts.id
+                                        ]),
+                                        method: "PUT",
+                                        body: JSON.stringify(opts.resource)
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "conditionalUpdate",
+            value: /**
+	 * Conditional Update allows a client to update an existing resource based on some identification criteria, rather than by logical id.
+	 *
+	 * The conditional `update` interaction is performed by an HTTP PUT command as shown:
+	 *
+	 * ```
+	 * PUT [base]/[type]?[search parameters]
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#cond-update
+	 *
+	 * @group Instance Level Interactions
+	 */ function conditionalUpdate(opts) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        url: makeUrl([
+                                            basePath,
+                                            opts.type
+                                        ]),
+                                        method: "PUT",
+                                        body: JSON.stringify(opts.resource),
+                                        params: opts.searchParameters
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "patch",
+            value: /**
+	 * Update an existing resource by posting a set of changes to it.
+	 *
+	 * The `patch` interaction is performed by an HTTP PATCH command as shown:
+	 *
+	 * ```
+	 * PATCH [base]/[type]/[id] {?_format=[mime-type]}
+	 * ```
+	 *
+	 * The body of a PATCH interaction is a JSON Patch icon document with a content type of `application/json-patch+json`.
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#patch
+	 *
+	 * @group Instance Level Interactions
+	 */ function patch(opts) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        url: makeUrl([
+                                            basePath,
+                                            opts.type,
+                                            opts.id
+                                        ]),
+                                        method: "PATCH",
+                                        headers: {
+                                            "Content-Type": "application/json-patch+json"
+                                        },
+                                        body: JSON.stringify(opts.patch)
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "conditionalPatch",
+            value: /**
+	 * Conditional Patch performs a search using the standard search facilities for the resource type, with the goal of resolving a single logical id for this request.
+	 * The action it takes depends on how many matches are found.
+	 *
+	 * The conditional `patch` interaction is performed by an HTTP PATCH command as shown:
+	 *
+	 * ```
+	 * PATCH [base]/[type]?param1=value&...{&_format=[mime-type]}
+	 * ```
+	 *
+	 * The body of a PATCH interaction is a JSON Patch icon document with a content type of `application/json-patch+json`.
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#cond-patch
+	 *
+	 * @group Instance Level Interactions
+	 */ function conditionalPatch(opts) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        url: makeUrl([
+                                            basePath,
+                                            opts.type
+                                        ]),
+                                        method: "PATCH",
+                                        headers: {
+                                            "Content-Type": "application/json-patch+json"
+                                        },
+                                        params: opts.searchParameters,
+                                        body: JSON.stringify(opts.patch)
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "delete",
+            value: /**
+	 * Delete a resource.
+	 *
+	 * The interaction is performed by an HTTP DELETE command as shown:
+	 *
+	 * ```
+	 * DELETE [base]/[type]/[id]
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#delete
+	 *
+	 * Example usage:
+	 *
+	 * ```typescript
+	 * const patient = await client.delete<Patient>({
+	 *   type: "Patient",
+	 *   id: "patient-id",
+	 * });
+	 * ```
+	 *
+	 * @group Instance Level Interactions
+	 */ function _delete(opts) {
+                return _async_to_generator(function() {
+                    var response, body;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _class_private_method_get(this, _internalRawRequest, internalRawRequest).call(this, {
+                                        url: makeUrl([
+                                            basePath,
+                                            opts.type,
+                                            opts.id
+                                        ]),
+                                        method: "DELETE"
+                                    })
+                                ];
+                            case 1:
+                                response = _state.sent();
+                                if (isInternalErrorResponse(response)) throw response.error;
+                                if (response.response.status === 204) return [
+                                    2,
+                                    Ok(_object_spread({
+                                        resource: undefined
+                                    }, response))
+                                ];
+                                return [
+                                    4,
+                                    coerceBody(response)
+                                ];
+                            case 2:
+                                body = _state.sent();
+                                if (!response.response.ok) {
+                                    if (body.resourceType === "OperationOutcome") return [
+                                        2,
+                                        Err(_object_spread({
+                                            resource: body
+                                        }, response))
+                                    ];
+                                    throw new ErrorResponse("HTTP ".concat(response.response.status, ": ").concat(response.response.statusText), response);
+                                }
+                                return [
+                                    2,
+                                    Ok(_object_spread({
+                                        resource: body
+                                    }, response))
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "deleteHistory",
+            value: /**
+	 * Delete all historical versions of a resource.
+	 *
+	 * The interaction is performed by an HTTP DELETE command as shown:
+	 *
+	 * ```
+	 * DELETE [base]/[type]/[id]/_history
+	 * ```
+	 *
+	 * FHIR Reference: https://build.fhir.org/http.html#delete-history
+	 *
+	 * @group Instance Level Interactions
+	 */ function deleteHistory(opts) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        url: makeUrl([
+                                            basePath,
+                                            opts.type,
+                                            opts.id,
+                                            "_history"
+                                        ]),
+                                        method: "DELETE"
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "deleteHistoryVersion",
+            value: /**
+	 * Delete a specific version of a resource.
+	 *
+	 * The interaction is performed by an HTTP DELETE command as shown:
+	 *
+	 * ```
+	 * DELETE [base]/[type]/[id]/_history/[vid]
+	 * ```
+	 *
+	 * FHIR Reference: https://build.fhir.org/http.html#delete-history-version
+	 *
+	 * @group Instance Level Interactions
+	 */ function deleteHistoryVersion(opts) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        url: makeUrl([
+                                            basePath,
+                                            opts.type,
+                                            opts.id,
+                                            "_history",
+                                            opts.vid
+                                        ]),
+                                        method: "DELETE"
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "conditionalDelete",
+            value: /**
+	 * Conditional Delete across all resource types based on some filter criteria
+	 *
+	 * If type is provided, performs conditional delete across a particular resource type based on some filter criteria.
+	 *
+	 * To accomplish this, the client issues an HTTP DELETE as shown:
+	 *
+	 * ```
+	 * DELETE [base]/[type]?[search parameters]
+	 * DELETE [base]?[search parameters]
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#cdelete
+	 *
+	 * @group Type Level Interactions
+	 * @group Whole System Interactions
+	 */ function conditionalDelete(opts) {
+                return _async_to_generator(function() {
+                    var url, requestParams;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                url = [
+                                    basePath
+                                ];
+                                if (opts.type) url.push(opts.type);
+                                requestParams = {
+                                    url: makeUrl(url),
+                                    method: "DELETE",
+                                    params: opts.searchParameters
+                                };
+                                return [
+                                    4,
+                                    this.request(requestParams)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "historyInstance",
+            value: /**
+	 * Retrieve the change history for a particular resource.
+	 *
+	 * The interaction is performed by an HTTP GET command as shown:
+	 *
+	 * ```
+	 * GET [base]/[type]/[id]/_history{?[parameters]&_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#history
+	 *
+	 * @group Instance Level Interactions
+	 */ function historyInstance(opts) {
+                return _async_to_generator(function() {
+                    var url, requestParams;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                url = [
                                     basePath,
                                     opts.type,
                                     opts.id,
                                     "_history"
-                                ]),
-                                method: "DELETE"
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var deleteHistoryVersion = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
+                                ];
+                                requestParams = {
+                                    url: makeUrl(url),
+                                    method: "GET"
+                                };
+                                return [
+                                    4,
+                                    this.request(requestParams)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "historySystem",
+            value: /**
+	 * Retrieve the change history for a particular resource type.
+	 *
+	 * The interaction is performed by an HTTP GET command as shown:
+	 *
+	 * ```
+	 * GET [base]/[type]/_history{?[parameters]&_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#history
+	 *
+	 * @group Whole System Interactions
+	 */ function historySystem(_) {
+                return _async_to_generator(function() {
+                    var url, requestParams;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                url = [
+                                    basePath,
+                                    "_history"
+                                ];
+                                requestParams = {
+                                    url: makeUrl(url),
+                                    method: "GET"
+                                };
+                                return [
+                                    4,
+                                    this.request(requestParams)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "historyType",
+            value: /**
+	 * Retrieve the change history for all resources.
+	 *
+	 * The interaction is performed by an HTTP GET command as shown:
+	 *
+	 * ```
+	 * GET [base]/_history{?[parameters]&_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#history
+	 *
+	 * @group Type Level Interactions
+	 */ function historyType(opts) {
+                return _async_to_generator(function() {
+                    var url, requestParams;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                url = [
                                     basePath,
                                     opts.type,
-                                    opts.id,
-                                    "_history",
-                                    opts.vid
-                                ]),
-                                method: "DELETE"
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var conditionalDelete = function(opts) {
-        return _async_to_generator(function() {
-            var url, requestParams;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        url = [
-                            basePath
-                        ];
-                        if (opts.type) url.push(opts.type);
-                        requestParams = {
-                            url: makeUrl(url),
-                            method: "DELETE",
-                            params: opts.searchParameters
-                        };
-                        return [
-                            4,
-                            request(requestParams)
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var historyInstance = function(opts) {
-        return _async_to_generator(function() {
-            var url, requestParams;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        url = [
-                            basePath,
-                            opts.type,
-                            opts.id,
-                            "_history"
-                        ];
-                        requestParams = {
-                            url: makeUrl(url),
-                            method: "GET"
-                        };
-                        return [
-                            4,
-                            request(requestParams)
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var historySystem = function(_) {
-        return _async_to_generator(function() {
-            var url, requestParams;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        url = [
-                            basePath,
-                            "_history"
-                        ];
-                        requestParams = {
-                            url: makeUrl(url),
-                            method: "GET"
-                        };
-                        return [
-                            4,
-                            request(requestParams)
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var historyType = function(opts) {
-        return _async_to_generator(function() {
-            var url, requestParams;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        url = [
-                            basePath,
-                            opts.type,
-                            "_history"
-                        ];
-                        requestParams = {
-                            url: makeUrl(url),
-                            method: "GET"
-                        };
-                        return [
-                            4,
-                            request(requestParams)
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var capabilities = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
+                                    "_history"
+                                ];
+                                requestParams = {
+                                    url: makeUrl(url),
+                                    method: "GET"
+                                };
+                                return [
+                                    4,
+                                    this.request(requestParams)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "capabilities",
+            value: /**
+	 * Get a capability statement for the system.
+	 *
+	 * The interaction is performed by an HTTP GET command as shown:
+	 *
+	 * ```
+	 * GET [base]/metadata{?mode=[mode]} {&_format=[mime-type]}
+	 * ```
+	 *
+	 * The `mode` can be:
+	 *
+	 * | Mode          | Description                                                                                                                  |
+	 * |---------------|------------------------------------------------------------------------------------------------------------------------------|
+	 * | `full`        | A `CapabilityStatement` that specifies which resource types and interactions are supported                                   |
+	 * | `normative`   | As above, but only the normative portions of the Capability Statement                                                        |
+	 * | `terminology` | A `TerminologyCapabilities` resource that provides further information about terminologies which are supported by the server |
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#capabilities
+	 *
+	 * @group Whole System Interactions
+	 */ function capabilities(opts) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        url: makeUrl([
+                                            basePath,
+                                            "metadata"
+                                        ]),
+                                        method: "GET",
+                                        headers: {
+                                            Accept: "application/fhir+json"
+                                        },
+                                        params: [
+                                            [
+                                                "mode",
+                                                opts.mode
+                                            ],
+                                            [
+                                                "_format",
+                                                "application/fhir+json"
+                                            ]
+                                        ]
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "batch",
+            value: /**
+	 * Perform multiple operations in a batch request (e.g. create, read, update, delete, patch, and/or [extended operations])
+	 *
+	 * A batch interaction is performed by an HTTP POST command as shown:
+	 *
+	 * ```
+	 * POST [base] {?_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#transaction
+	 *
+	 * @group Whole System Interactions
+	 */ function batch(opts) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        url: makeUrl([
+                                            basePath
+                                        ]),
+                                        method: "POST",
+                                        params: [
+                                            [
+                                                "_format",
+                                                opts.format
+                                            ]
+                                        ],
+                                        body: JSON.stringify(opts.bundle)
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "transaction",
+            value: /**
+	 * Perform multiple operations as a transaction (e.g. create, read, update, delete, patch, and/or [extended operations])
+	 *
+	 * A transaction interaction is performed by an HTTP POST command as shown:
+	 *
+	 * ```
+	 * POST [base] {?_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/http.html#transaction
+	 *
+	 * @group Whole System Interactions
+	 */ function transaction(opts) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        url: makeUrl([
+                                            basePath
+                                        ]),
+                                        method: "POST",
+                                        params: [
+                                            [
+                                                "_format",
+                                                opts.format
+                                            ]
+                                        ],
+                                        body: JSON.stringify(opts.bundle)
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "operation",
+            value: /**
+	 * Perform an operation as defined by an `OperationDefinition`.
+	 *
+	 * The interaction is performed by an HTTP POST command as shown:
+	 *
+	 * ```
+	 * POST [base]/[type]/[operation] {?_format=[mime-type]}
+	 * POST [base]/[type]/[id]/[operation] {?_format=[mime-type]}
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/operations.html
+	 *
+	 * @group Operations
+	 */ function operation(opts) {
+                return _async_to_generator(function() {
+                    var url, requestParams;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                url = [
                                     basePath,
-                                    "metadata"
-                                ]),
-                                method: "GET",
-                                headers: {
-                                    Accept: "application/fhir+json"
-                                },
-                                params: [
-                                    [
-                                        "mode",
-                                        opts.mode
-                                    ],
-                                    [
-                                        "_format",
-                                        "application/fhir+json"
-                                    ]
-                                ]
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var batch = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
-                                    basePath
-                                ]),
-                                method: "POST",
-                                params: [
-                                    [
-                                        "_format",
-                                        opts.format
-                                    ]
-                                ],
-                                body: JSON.stringify(opts.bundle)
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var transaction = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            request({
-                                url: makeUrl([
-                                    basePath
-                                ]),
-                                method: "POST",
-                                params: [
-                                    [
-                                        "_format",
-                                        opts.format
-                                    ]
-                                ],
-                                body: JSON.stringify(opts.bundle)
-                            })
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var operation = function(opts) {
-        return _async_to_generator(function() {
-            var url, requestParams;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        url = [
-                            basePath
-                        ];
-                        if (opts.type) url.push(opts.type);
-                        if (opts.id) url.push(opts.id);
-                        url.push(opts.operation);
-                        requestParams = {
-                            url: makeUrl(url),
-                            method: "POST"
-                        };
-                        if (opts.resource) requestParams.body = JSON.stringify(opts.resource);
-                        return [
-                            4,
-                            request(requestParams)
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    var validate = function(opts) {
-        return _async_to_generator(function() {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            operation(_object_spread({
-                                operation: "$validate"
-                            }, opts))
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        })();
-    };
-    return {
-        // General
-        getBaseUrl: getBaseUrl,
-        rawRequest: rawRequest,
-        request: request,
-        // Aidbox
-        performLogout: performLogout,
-        fetchUserInfo: fetchUserInfo,
-        // FHIR HTTP
-        read: read,
-        vread: vread,
-        searchType: searchType,
-        searchSystem: searchSystem,
-        searchCompartment: searchCompartment,
-        create: create,
-        conditionalCreate: conditionalCreate,
-        update: update,
-        conditionalUpdate: conditionalUpdate,
-        patch: patch,
-        conditionalPatch: conditionalPatch,
-        delete: deleteOp,
-        deleteHistory: deleteHistory,
-        deleteHistoryVersion: deleteHistoryVersion,
-        conditionalDelete: conditionalDelete,
-        historyInstance: historyInstance,
-        historyType: historyType,
-        historySystem: historySystem,
-        capabilities: capabilities,
-        batch: batch,
-        transaction: transaction,
-        operation: operation,
-        validate: validate
-    };
+                                    opts.type
+                                ];
+                                if (opts.id) url.push(opts.id);
+                                url.push(opts.operation);
+                                requestParams = {
+                                    url: makeUrl(url),
+                                    method: "POST"
+                                };
+                                if (opts.resource) requestParams.body = JSON.stringify(opts.resource);
+                                return [
+                                    4,
+                                    this.request(requestParams)
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "validate",
+            value: /**
+	 * Perform the Validate Operation.
+	 *
+	 * The interaction is performed by an HTTP POST command as shown:
+	 *
+	 * ```
+	 * [base]/[type]/$validate
+	 * [base]/[type]/[id]/$validate
+	 * ```
+	 *
+	 * FHIR Reference: https://hl7.org/fhir/operation-resource-validate.html
+	 *
+	 * @group Operations
+	 */ function validate(opts) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.operation(_object_spread({
+                                        operation: "$validate"
+                                    }, opts))
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "userinfo",
+            value: /**
+	 * Performs a request to `/auth/userinfo`.
+	 *
+	 * @group Aidbox methods
+	 */ function userinfo() {
+                return _async_to_generator(function() {
+                    var user;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.rawRequest({
+                                        url: "/auth/userinfo",
+                                        method: "GET",
+                                        headers: {
+                                            "Content-Type": "application/json",
+                                            Accept: "application/json"
+                                        }
+                                    }).then(function(response) {
+                                        return coerceBody(response);
+                                    })
+                                ];
+                            case 1:
+                                user = _state.sent();
+                                return [
+                                    2,
+                                    user
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "logout",
+            value: /**
+	 * Performs a request to `/auth/logout`.
+	 *
+	 * @group Aidbox methods
+	 */ function logout() {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.rawRequest({
+                                        url: "/auth/logout",
+                                        method: "POST",
+                                        headers: {
+                                            "Content-Type": "application/json",
+                                            Accept: "application/json"
+                                        }
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent().response
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "request",
+            value: /**
+	 * Typed request
+	 *
+	 * Example usage:
+	 *
+	 * ```typescript
+	 * const result = client.request<Patient>({
+	 *   method: "GET",
+	 *   url: "/fhir/Patient/pt-1",
+	 * })
+	 *
+	 * if (isOk(result)) {
+	 *   const { value } = result;
+	 *   // work with value as a Patient type
+	 * } else {
+	 *   const { error } = result;
+	 *   // work with error as an OperationOutcome type.
+	 * }
+	 * ```
+	 *
+	 * @group Client methods
+	 */ function request(params) {
+                return _async_to_generator(function() {
+                    var response, body;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _class_private_method_get(this, _internalRawRequest, internalRawRequest).call(this, params)
+                                ];
+                            case 1:
+                                response = _state.sent();
+                                if (isInternalErrorResponse(response)) throw response.error;
+                                return [
+                                    4,
+                                    coerceBody(response)
+                                ];
+                            case 2:
+                                body = _state.sent();
+                                if (!response.response.ok) {
+                                    if (body.resourceType === "OperationOutcome") return [
+                                        2,
+                                        Err(_object_spread({
+                                            resource: body
+                                        }, response))
+                                    ];
+                                    throw new ErrorResponse("HTTP ".concat(response.response.status, ": ").concat(response.response.statusText), response);
+                                }
+                                return [
+                                    2,
+                                    Ok(_object_spread({
+                                        resource: body
+                                    }, response))
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "rawRequest",
+            value: /**
+	 * Untyped request.
+	 *
+	 * Example usage:
+	 *
+	 * ```typescript
+	 * const result = client.rawRequest({
+	 *   method: "GET",
+	 *   url: "/fhir/Patient/pt-1",
+	 * })
+	 * ```
+	 *
+	 * @group Client methods
+	 */ function rawRequest(requestParams) {
+                return _async_to_generator(function() {
+                    var result;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _class_private_method_get(this, _internalRawRequest, internalRawRequest).call(this, requestParams)
+                                ];
+                            case 1:
+                                result = _state.sent();
+                                if (isInternalErrorResponse(result)) throw result.error;
+                                if (!result.response.ok) throw new ErrorResponse("HTTP ".concat(result.response.status, ": ").concat(result.response.statusText), result);
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "getBaseUrl",
+            value: /**
+	 * Obtain server's base URL.
+	 *
+	 * @group Client methods
+	 */ function getBaseUrl() {
+                return this.baseUrl;
+            }
+        }
+    ]);
+    return AidboxClient;
+}();
+function internalRawRequest(requestParams) {
+    return _async_to_generator(function() {
+        var startTime, baseUrl, method, url, _requestParams_headers, headers, _requestParams_params, params, body, urlObj, requestHeaders, request, response, responseHeaders, e;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    startTime = performance.now();
+                    baseUrl = this.getBaseUrl();
+                    if (!requestParams.url.startsWith("/")) return [
+                        2,
+                        {
+                            error: new RequestError("URL must start with a forward slash", {
+                                request: requestParams
+                            }),
+                            duration: performance.now() - startTime,
+                            request: requestParams
+                        }
+                    ];
+                    method = requestParams.method, url = requestParams.url, _requestParams_headers = requestParams.headers, headers = _requestParams_headers === void 0 ? {} : _requestParams_headers, _requestParams_params = requestParams.params, params = _requestParams_params === void 0 ? [] : _requestParams_params, body = requestParams.body;
+                    urlObj = new URL(url, baseUrl);
+                    params.forEach(function(param) {
+                        var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+                        urlObj.searchParams.append(key, value);
+                    });
+                    requestHeaders = {
+                        "content-type": "application/json",
+                        accept: "application/json"
+                    };
+                    Object.entries(headers).forEach(function(param) {
+                        var _param = _sliced_to_array(param, 2), header = _param[0], value = _param[1];
+                        requestHeaders[header.toLowerCase()] = value;
+                    });
+                    request = {
+                        method: method,
+                        url: url,
+                        params: params,
+                        headers: requestHeaders,
+                        body: body !== null && body !== void 0 ? body : ""
+                    };
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    return [
+                        4,
+                        this.authProvider.fetch(urlObj.toString(), {
+                            method: method,
+                            headers: requestHeaders,
+                            body: body || null,
+                            cache: "no-store"
+                        })
+                    ];
+                case 2:
+                    response = _state.sent();
+                    responseHeaders = {};
+                    response.headers.forEach(function(value, key) {
+                        responseHeaders[key] = value;
+                    });
+                    return [
+                        2,
+                        {
+                            response: response,
+                            responseHeaders: responseHeaders,
+                            duration: performance.now() - startTime,
+                            request: request
+                        }
+                    ];
+                case 3:
+                    e = _state.sent();
+                    return [
+                        2,
+                        {
+                            error: new RequestError(e && (typeof e === "undefined" ? "undefined" : _type_of(e)) === "object" && "message" in e ? "error during request: ".concat(e.message) : "unknown error during request", {
+                                cause: e,
+                                request: request
+                            }),
+                            duration: performance.now() - startTime,
+                            request: request
+                        }
+                    ];
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).call(this);
 }