SMART on FHIR JavaScript Library

http://docs.smarthealthit.org/client-js/
Admin
A JavaScript library for connecting SMART applications to FHIR servers, providing OAuth2...
Tokens:71,012
Snippets:523
Trust Score:9.9
Update:6 months ago
Show doc for...
Tokens:
Raw
### SMART.authorize

Source: http://docs.smarthealthit.org/client-js/typedoc/interfaces/types.fhirclient.SMART.html

Starts the SMART Launch Sequence by redirecting the user to the authorization server.

```APIDOC
## POST authorize

### Description
Starts the SMART Launch Sequence. Note that this method triggers a redirect to the authorization server.

### Method
POST

### Parameters
#### Request Body
- **options** (AuthorizeParams) - Required - Configuration options including clientId, scope, and optionally iss for standalone launch.
```

--------------------------------

### authorize

Source: http://docs.smarthealthit.org/client-js/typedoc/modules/smart.html

Starts the SMART Launch Sequence. This function will redirect the user to the authorization server.

```APIDOC
## POST /oauth2/authorize

### Description
Starts the SMART Launch Sequence. This function will redirect the user to the authorization server. Any code following this call might not be executed due to the redirect.

### Method
POST

### Endpoint
/oauth2/authorize

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **env** (Adapter) - Required - The adapter for the environment.
- **params** (AuthorizeParams | AuthorizeParams[]) - Optional - Parameters for authorization.

### Request Example
```json
{
  "env": "<Adapter Object>",
  "params": {}
}
```

### Response
#### Success Response (200)
- **string | void** - A string representing the authorization code or void if no code is returned.

#### Response Example
```json
"authorization_code_string"
```
```

--------------------------------

### Install fhirclient via npm

Source: http://docs.smarthealthit.org/client-js/typedoc/index.html

Use this command to add the library to your project dependencies.

```bash
npm i fhirclient
```

--------------------------------

### Connect fhir.js to Smart Health IT Client

Source: http://docs.smarthealthit.org/client-js/node.html

Install fhir.js and use the `connect` method of the Smart Health IT client to integrate it. This example shows how to initialize the client and perform a patient search.

```javascript
const smart  = require("fhirclient");
const fhirJs = require("fhir.js");

// Inside a route handler
app.get("/", async (req, res) => {
    const client = await smart(req, res).ready();
    client.connect(fhirJs);
    client.api.search({ type: "Patient" }).then(res.json).catch(res.json);
});


```

--------------------------------

### Complete Authorization Flow with ready()

Source: http://docs.smarthealthit.org/client-js/node.html

In your redirect_uri route handler, use the `ready` function to finalize the authorization flow and get a FhirClient instance. The callback function receives the client instance to perform requests.

```javascript
const smart = require("fhirclient");

// inside your redirect_uri route handler
smart(request, response).ready(client => client.request("Patient"));
```

--------------------------------

### Start Authorization Flow with authorize()

Source: http://docs.smarthealthit.org/client-js/node.html

Call the `authorize` function within your launch_uri route handler to initiate the OAuth2 authorization process. Ensure your request object has session support.

```javascript
const smart = require("fhirclient");

// inside your launch_uri route handler
smart(request, response).authorize({
    "client_id": "my_web_app",
    "scope"    : "launch patient/*.read openid fhirUser"
});
```

--------------------------------

### Building Query Strings

Source: http://docs.smarthealthit.org/client-js/fhirjs-equivalents.html

Examples of how to build complex query strings for searching FHIR resources.

```APIDOC
### Building Query Strings

When not using fhir.js's higher-level abstractions, you can construct query strings manually or using `URLSearchParams`.

#### Example 1: First 10 patients sorted by name
```javascript
const query = new URLSearchParams();
query.set("_sort", "name");
query.set("_count", 10);
client.request(`Patient?${query}`);
```

#### Example 2: Fetching Vitals with specific codes and pagination
```javascript
function fetchVitals(client) {
    var query = new URLSearchParams();
    query.set("patient", client.patient.id);
    query.set("_count", 100); // Try this to fetch fewer pages
    query.set("code", [
        'http://loinc.org|29463-7', // weight
        'http://loinc.org|3141-9' , // weight
        'http://loinc.org|8302-2' , // Body height
        'http://loinc.org|8306-3' , // Body height --lying
        'http://loinc.org|8287-5' , // headC
        'http://loinc.org|39156-5', // BMI 39156-5
        'http://loinc.org|18185-9', // gestAge
        'http://loinc.org|37362-1', // bone age
        'http://loinc.org|11884-4'  // gestAge
    ].join(","));
    return client.request("Observation?" + query, {
        pageLimit: 0,   // get all pages
        flat: true // return flat array of Observation resources
    });
}
```
```

--------------------------------

### Get all pages

Source: http://docs.smarthealthit.org/client-js/request.html

Retrieves all available pages for a resource request by setting pageLimit to 0.

```javascript
const client = new FHIR.client("https://r3.smarthealthit.org");
client.request("/Claim", { pageLimit: 0 });
```

```javascript
function display(data) {
    const output = document.getElementById("output");
    output.innerText = data instanceof Error ?
        String(data) :
        JSON.stringify(data, null, 4);
}

const client = new FHIR.client("https://r3.smarthealthit.org");
client.request("/Claim", { pageLimit: 0 })
    .then(display).catch(display);
```

--------------------------------

### Express Server Integration

Source: http://docs.smarthealthit.org/client-js

Example of handling SMART on FHIR authorization and requests within an Express application.

```javascript
const fhirClient = require("fhirclient");

// This is what the EHR will call
app.get("/launch", (req, res) => {
    fhirClient(req, res).authorize({
        "client_id": "my_web_app",
        "scope": "patient/*.read"
    });
});

// This is what the Auth server will redirect to
app.get("/", (req, res) => {
    fhirClient(req, res).ready()
        .then(client => client.request("Patient"))
        .then(res.json)
        .catch(res.json);
});
```

--------------------------------

### Get multiple pages

Source: http://docs.smarthealthit.org/client-js/request.html

Fetches a limited number of pages using the pageLimit option, returning an array of page bundles.

```javascript
const client = new FHIR.client("https://r3.smarthealthit.org");
client.request("/Patient", { pageLimit: 2 });
```

```javascript
function display(data) {
    const output = document.getElementById("output");
    output.innerText = data instanceof Error ?
        String(data) :
        JSON.stringify(data, null, 4);
}

const client = new FHIR.client("https://r3.smarthealthit.org");
client.request("/Patient", { pageLimit: 2 }).then(display).catch(display);
```

--------------------------------

### Using Different Adapters (e.g., HAPI)

Source: http://docs.smarthealthit.org/client-js/node.html

Demonstrates how to load and use specific adapters for different environments or frameworks, such as the HAPI adapter for the HAPI framework.

```APIDOC
## Using Different Adapters (e.g., HAPI)

### Description
Demonstrates how to load and use specific adapters for different environments or frameworks, such as the HAPI adapter for the HAPI framework.

### Method
```javascript
// For HAPI adapter
const smart = require("fhirclient/lib/entry/hapi");

// inside your redirect_uri route handler
smart(request, h).ready(client => client.request("Patient"));
```

### Endpoint
`/your_hapi_route`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const smart = require("fhirclient/lib/entry/hapi");

// inside your redirect_uri route handler
smart(request, h).ready(client => client.request("Patient"));
```

### Response
#### Success Response (200 OK)
Returns a FhirClient instance configured for the HAPI environment.

#### Response Example
```javascript
// client object is available in the callback
client.request("Patient").then(patient => console.log(patient));
```
```

--------------------------------

### init

Source: http://docs.smarthealthit.org/client-js/typedoc/modules/smart.html

Initializes the SMART client for single-page applications where the launch_uri and redirect_uri are the same.

```APIDOC
## POST /init

### Description
This function can be used when you want to handle everything in one page (no launch endpoint needed). It internally calls `authorize(options).then(ready)`. Be careful as this function might be called twice during the authorization flow.

### Method
POST

### Endpoint
/init

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **env** (Adapter) - Required - The adapter for the environment.
- **authorizeOptions** (AuthorizeParams) - Required - The authorize options.
- **readyOptions** (ReadyOptions) - Optional - The ready options.

### Request Example
```json
{
  "env": "<Adapter Object>",
  "authorizeOptions": {
    "clientId": "<client_id>",
    "scope": "launch openid profile",
    "redirectUri": "<redirect_uri>"
  },
  "readyOptions": {}
}
```

### Response
#### Success Response (200)
- **default | never** - The initialized client or never if initialization fails.

#### Response Example
```json
{
  "client": "<FHIRClient Instance>"
}
```
```

--------------------------------

### drop(limit, options)

Source: http://docs.smarthealthit.org/client-js/typedoc/interfaces/types.fhirclient.RequestWithSession.html

Drops a specified number of chunks from the start of the readable stream.

```APIDOC
## drop(limit, options)

### Description
Drops a specified number of chunks from the start of the readable stream.

### Parameters
- **limit** (number) - Required - The number of chunks to drop from the readable.
- **options** (Pick<ArrayOptions, "signal">) - Optional - Configuration options.

### Returns
- **Readable** - A stream with limit chunks dropped from the start.
```

--------------------------------

### init(authorizeOptions, readyOptions)

Source: http://docs.smarthealthit.org/client-js/api

Experimental method to handle the full authorization flow in a single page by combining authorize and ready calls.

```APIDOC
## init(authorizeOptions, readyOptions)

### Description
This function can be used when you want to handle everything in one page (no launch endpoint needed). It internally performs an authorize call followed by a ready call.

### Parameters
#### Request Body
- **authorizeOptions** (object) - Required - The same object passed to the authorize method.
- **readyOptions** (object) - Optional - The same object passed to the ready method.

### Response
#### Success Response (200)
- **Client** (Promise) - A Promise that resolves with a Client instance.
```

--------------------------------

### init(options)

Source: http://docs.smarthealthit.org/client-js/node.html

Handles the entire authorization process within a single route, suitable when the launch_uri is the same as the redirect_uri. Not available with HAPI.

```APIDOC
## init(options)

### Description
Handles the entire authorization process within a single route, suitable when the launch_uri is the same as the redirect_uri. Not available with HAPI.

### Method
GET or POST (depending on initial request)

### Endpoint
`/your_single_route`

### Parameters
#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const smart = require("fhirclient");

// inside your route handler
smart(request, response).init({
    "client_id": "my_web_app",
    "scope"    : "launch patient/*.read openid fhirUser"
}).then(client => client.request("Patient"));
```

### Response
#### Success Response (200 OK)
Returns a FhirClient instance after completing the authorization flow.

#### Response Example
```javascript
// client object is available in the promise
.then(client => {
    client.request("Patient").then(patient => console.log(patient));
});
```
```

--------------------------------

### Get User ID

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/Client.default.html

Retrieves the ID of the logged-in user, or null if no user is logged in.

```typescript
client.getUserId()
```

--------------------------------

### Browser Launch and Index Pages (Script Tag)

Source: http://docs.smarthealthit.org/client-js

Configure the launch and index pages using the library via a script tag.

```html
<!-- launch.html -->
<script src="./node_module/fhirclient/build/fhir-client.js"></script>
<script>
FHIR.oauth2.authorize({
    "client_id": "my_web_app",
    "scope": "patient/*.read"
});
</script>
```

```html
<!-- index.html -->
<script src="./node_module/fhirclient/build/fhir-client.js"></script>
<script>
FHIR.oauth2.ready()
    .then(client => client.request("Patient"))
    .then(console.log)
    .catch(console.error);
</script>
```

--------------------------------

### FHIRClient Initialization

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/Client.default.html

Demonstrates how to initialize the FHIRClient in both browser and server environments.

```APIDOC
## FHIRClient Initialization

### Description
This section shows how to create an instance of the FHIRClient.

### Request Example
```javascript
// BROWSER
const client = FHIR.client("https://r4.smarthealthit.org");

// SERVER
const client = smart(req, res).client("https://r4.smarthealthit.org");
```
```

--------------------------------

### ready()

Source: http://docs.smarthealthit.org/client-js/node.html

Completes the authorization flow and obtains a FhirClient instance. Call this in your redirect_uri route handler.

```APIDOC
## ready()

### Description
Completes the authorization flow and obtains a FhirClient instance. Call this in your redirect_uri route handler.

### Method
GET

### Endpoint
`/your_redirect_uri`

### Parameters
#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const smart = require("fhirclient");

// inside your redirect_uri route handler
smart(request, response).ready(client => client.request("Patient"));
```

### Response
#### Success Response (200 OK)
Returns a FhirClient instance that can be used to make FHIR requests.

#### Response Example
```javascript
// client object is available in the callback
client.request("Patient").then(patient => console.log(patient));
```
```

--------------------------------

### Initialization and Ready State

Source: http://docs.smarthealthit.org/client-js/typedoc/modules/smart.html

Function to initialize the client and prepare it for use after redirect or refresh.

```APIDOC
## ready

### Description
Initializes the smarthealthit client. This function should be called on the page specified by `redirectUri` after an authorization server redirect, or upon subsequent page loads/refreshes.

### Method
`ready(env: Adapter, options?: ReadyOptions): Promise<default>`

### Parameters
#### Request Body
- **env** (Adapter) - Required - The adapter configuration for the environment.
- **options** (ReadyOptions) - Optional - Additional options for initialization. Defaults to an empty object.
```

--------------------------------

### Get ID Token

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/Client.default.html

Retrieves the decoded ID token. Requires 'openid' and 'profile' scopes to be requested.

```typescript
client.getIdToken()
```

--------------------------------

### ready(options)

Source: http://docs.smarthealthit.org/client-js/api

Initializes the FHIR client on the redirect_uri page. Returns a Promise that resolves with a Client instance.

```APIDOC
## ready(options)

### Description
This should be called on your redirect_uri. Returns a Promise that will eventually be resolved with a Client instance that you can use to query the fhir server.

### Parameters
#### Request Body
- **clientPublicKeySetUrl** (String) - Optional - If you have registered a confidential client and you host your public key online, you can pass your JWKS URL here.
- **clientPrivateJwk** (object) - Optional - If you have registered a confidential client, you should pass your private key here. Can be a JWK object or an object containing { key: CryptoKey, alg: string, kid: string }.

### Response
#### Success Response (200)
- **Client** (Promise) - A Promise that resolves with a Client instance.
```

--------------------------------

### Get User Type

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/Client.default.html

Retrieves the type of the logged-in user (e.g., 'Practitioner', 'Patient', 'RelatedPerson'), or null if not applicable.

```typescript
client.getUserType()
```

--------------------------------

### Initialize SMART API in Browser and Server

Source: http://docs.smarthealthit.org/client-js/api

Demonstrates how to access the SMART API in both browser and Node.js environments. In the browser, it's available globally. In Node.js, it's initialized with request and response objects.

```javascript
// BROWSER
const smart = FHIR.oauth2;
smart.authorize(options);
```

```javascript
// SERVER
const smart = require("fhirclient");
smart(request, response).authorize(options);
```

--------------------------------

### Get Patient ID

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/Client.default.html

Retrieves the ID of the currently selected patient. Requires the 'launch/patient' scope to be requested, otherwise returns null.

```typescript
client.getPatientId()
```

--------------------------------

### SMART API Initialization

Source: http://docs.smarthealthit.org/client-js

Comparison of SMART API initialization between browser and server environments.

```javascript
// BROWSER
const smart = FHIR.oauth2;
smart.authorize(options);

// SERVER
const smart = require("fhirclient");
smart(request, response).authorize(options);
```

--------------------------------

### Method - get

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/storage_ServerStorage.default.html

Retrieves a value from the client based on a provided key. Returns a promise that resolves with the value or undefined if the key does not exist.

```APIDOC
## get

### Description
Gets the value at `key`. Returns a promise that will be resolved with that value (or undefined for missing keys).

### Parameters
#### key: string

### Returns
Promise<any>
```

--------------------------------

### Browser Launch and Index Pages (Module)

Source: http://docs.smarthealthit.org/client-js

Use the library as an ES module in browser environments.

```javascript
import FHIR from "fhirclient"
FHIR.oauth2.authorize({
    "client_id": "my_web_app",
    "scope": "patient/*.read"
});
```

```javascript
import FHIR from "fhirclient"
FHIR.oauth2.ready()
    .then(client => client.request("Patient"))
    .then(console.log)
    .catch(console.error);
```

--------------------------------

### BrowserAdapter Constructor

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/adapters_BrowserAdapter.default.html

Initializes a new instance of the BrowserAdapter class.

```APIDOC
## new default(options?: BrowserFHIRSettings): default

### Description
Initializes a new instance of the BrowserAdapter class.

### Parameters
#### options: BrowserFHIRSettings = {}
Environment-specific options

### Returns default
```

--------------------------------

### Retrieve raw event listeners

Source: http://docs.smarthealthit.org/client-js/typedoc/interfaces/types.fhirclient.RequestWithSession.html

Use rawListeners to get a copy of the listener array for a specific event, including wrappers created by .once().

```javascript
const emitter = new EventEmitter();  
emitter.once('log', () => console.log('log once'));  
  
// Returns a new Array with a function `onceWrapper` which has a property  
// `listener` which contains the original listener bound above  
const listeners = emitter.rawListeners('log');  
const logFnWrapper = listeners[0];  
  
// Logs "log once" to the console and does not unbind the `once` event  
logFnWrapper.listener();  
  
// Logs "log once" to the console and removes the listener  
logFnWrapper();  
  
emitter.on('log', () => console.log('log persistently'));  
// Will return a new Array with a single function bound by `.on()` above  
const newListeners = emitter.rawListeners('log');  
  
// Logs "log persistently" twice  
newListeners[0]();  
emitter.emit('log');
```

--------------------------------

### Get Client State

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/Client.default.html

Returns a copy of the client's current state. Accepts an optional dot-separated path to select specific properties.

```typescript
client.getState()
```

```typescript
client.getState("serverUrl")
```

```typescript
client.getState("tokenResponse.patient")
```

--------------------------------

### Get References from Resource

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/Client.default.html

Fetches all references within a given FHIR resource, automatically handling duplicates. Optional request options can be provided.

```typescript
client.getReferences(resource, references, requestOptions)
```

--------------------------------

### SMART.init

Source: http://docs.smarthealthit.org/client-js/typedoc/interfaces/types.fhirclient.SMART.html

Handles the authorization flow in a single page application.

```APIDOC
## POST init

### Description
Handles the authorization flow in a single page. It performs the redirect to the EHR and handles the return redirect to complete authorization.

### Method
POST

### Parameters
#### Request Body
- **options** (AuthorizeParams) - Required - Configuration options for the initialization process.
```

--------------------------------

### Constructor - HapiAdapter

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/adapters_HapiAdapter.default.html

Initializes a new instance of the HapiAdapter with environment-specific options.

```APIDOC
## constructor

### Description
Creates a new instance of the HapiAdapter.

### Parameters
#### Path Parameters
- **options** (HapiAdapterOptions) - Required - Environment-specific configuration options.
```

--------------------------------

### Get Value from Object by Path

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/Client.default.html

Retrieves a value from a nested object or array using a dot-separated string path. Returns undefined if the path is invalid. This function is intentionally simple and does not support argument polymorphism.

```javascript
client.getPath(obj, "a.b.4.c")
```

--------------------------------

### Fetch All With References

Source: http://docs.smarthealthit.org/client-js/fhirjs-equivalents.html

Retrieve all pages and resolve specified references.

```javascript
client.request("ResourceType?optional-query", {
    pageLimit: 0,
    resolveReferences: [ "someReference" ],
    graph: false // Set to true or omit to have the references mounted into the resource tree
})
```

--------------------------------

### Initialize SMART Client

Source: http://docs.smarthealthit.org/client-js/typedoc/modules/smart.html

Combines authorize and ready calls into a single function for single-page applications. Ensure the application logic is wrapped to handle the two-stage execution flow.

```javascript
authorize(options).then(ready)
```

--------------------------------

### Get FHIR References as Separate Object

Source: http://docs.smarthealthit.org/client-js/client.html

Fetches a FHIR resource, resolves references, and returns the original data and resolved references separately. Set graph to false to enable this. Resolves with an object containing 'data' and 'references' or rejects with an error.

```javascript
client.request("Encounter/518a522a-4b10-47db-9daf-53b726d32607", {
    resolveReferences: [ "serviceProvider" ],
    graph: false
});
```

--------------------------------

### Handle Authorization in a Single Route with init()

Source: http://docs.smarthealthit.org/client-js/node.html

Use the `init` function to manage the entire authorization process within a single route handler, provided your launch_uri and redirect_uri are the same. This method is not compatible with HAPI.

```javascript
const smart = require("fhirclient");

// inside your route handler
smart(request, response).init({
    "client_id": "my_web_app",
    "scope"    : "launch patient/*.read openid fhirUser"
}).then(client => client.request("Patient"));
```

--------------------------------

### Static Method - smart

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/adapters_HapiAdapter.default.html

The static entry point for initializing the SMART API within a Hapi request context.

```APIDOC
## Static smart

### Description
Initializes and returns a SMART API instance using the provided Hapi request and response toolkit.

### Parameters
- **request** (Request) - Required - The Hapi request object.
- **h** (ResponseToolkit) - Required - The Hapi response toolkit.
- **storage** (Storage | storageFactory) - Optional - Custom storage instance or factory function.

### Response
- **SMART** - Returns the initialized SMART API instance.
```

--------------------------------

### export= (Node.js Initialization)

Source: http://docs.smarthealthit.org/client-js/typedoc/modules/entry_node.html

Initializes the SMART client in a Node.js environment using incoming HTTP request and response objects.

```APIDOC
## export=(request, response, storage)

### Description
Initializes the SMART client for Node.js applications by providing the necessary HTTP context and optional storage configuration.

### Parameters
#### Arguments
- **request** (IncomingMessage) - Required - The Node.js incoming HTTP request object.
- **response** (ServerResponse<IncomingMessage>) - Required - The Node.js server response object.
- **storage** (Storage | storageFactory) - Optional - Custom storage implementation or factory for session/token persistence.

### Returns
- **SMART** - Returns an initialized SMART client instance.
```

--------------------------------

### Using a Storage Factory Function

Source: http://docs.smarthealthit.org/client-js/node.html

Recommended approach for custom storage: provide a factory function that creates a storage instance based on the request and response objects.

```javascript
function createStorage({ request, response }) {
    return new AwesomeCustomStorage(request, response);
}

// inside a route handler
smart(request, response, createStorage).authorize(options)
```

--------------------------------

### Module adapters/NodeAdapter

Source: http://docs.smarthealthit.org/client-js/typedoc/modules/adapters_NodeAdapter.html

Documentation for the NodeAdapter module, including its index and classes.

```APIDOC
## Module adapters/NodeAdapter

### Index

### Classes
  * default
```

--------------------------------

### Node Adapter Methods

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/adapters_NodeAdapter.default.html

Provides information on the methods available for NodeAdapter instances.

```APIDOC
## Methods

### atob
`atob(str: string): string`

ASCII string to Base64.

#### Parameters
##### str: string
#### Returns string

### base64urldecode
`base64urldecode(input: string): string`

Base64Url to ASCII string.

#### Parameters
##### input: string
#### Returns string

### base64urlencode
`base64urlencode(input: string | Uint8Array): string`

ASCII string or Uint8Array to Base64URL.

#### Parameters
##### input: string | Uint8Array
#### Returns string

### btoa
`btoa(str: string): string`

Base64 to ASCII string.

#### Parameters
##### str: string
#### Returns string

### getAbortController
`getAbortController(): { prototype: AbortController }`

Returns a reference to the AbortController constructor. In browsers, AbortController will always be available as global (native or polyfilled).

#### Returns { prototype: AbortController }
##### prototype: AbortController

### getProtocol
`getProtocol(): string`

Returns the protocol of the current request ("http" or "https").

#### Returns string

### getSmartApi
`getSmartApi(): SMART`

Creates and returns adapter-aware SMART api. Not that while the shape of the returned object is well known, the arguments to this function are not. Those who override this method are free to require any environment-specific arguments. For example in node we will need a request, a response and optionally a storage or storage factory function.

#### Returns SMART

### getStorage
`getStorage(): Storage`

Returns a ServerStorage instance.

#### Returns Storage

### getUrl
`getUrl(): URL`

Given the current environment, this method must return the current url as URL instance. In Node we might be behind a proxy!

#### Returns URL

### redirect
`redirect(location: string): void`

Given the current environment, this method must redirect to the given path.

#### Parameters
##### location: string
The path to redirect to
#### Returns void

### relative
`relative(path: string): string`

Given a relative path, returns an absolute url using the instance base URL.

#### Parameters
##### path: string
#### Returns string
```

--------------------------------

### Node Adapter Constructor

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/adapters_NodeAdapter.default.html

Initializes a new instance of the NodeAdapter class.

```APIDOC
## new default(options: NodeAdapterOptions): default

### Description
Initializes a new instance of the NodeAdapter class.

### Parameters
#### options: NodeAdapterOptions
Environment-specific options

#### Returns default
```

--------------------------------

### SMART.ready

Source: http://docs.smarthealthit.org/client-js/typedoc/interfaces/types.fhirclient.SMART.html

Finalizes the authorization process on the redirect URI.

```APIDOC
## GET ready

### Description
Should be called on the redirect_uri to finalize the authorization and return a Client instance.

### Method
GET

### Parameters
#### Query Parameters
- **options** (ReadyOptions) - Optional - Configuration options for the ready state.
```

--------------------------------

### Fetch All with References

Source: http://docs.smarthealthit.org/client-js/fhirjs-equivalents.html

Fetches all resources and resolves specified references.

```APIDOC
## GET ResourceType?optional-query (with reference resolution)

### Description
Fetches all resources of a specified type and resolves specified references within those resources. References can be mounted into the resource tree if `graph` is set to true.

### Method
GET

### Endpoint
`ResourceType?optional-query`

### Parameters
#### Path Parameters
- **ResourceType** (string) - Required - The type of FHIR resource to fetch.

#### Query Parameters
- **optional-query** (string) - Optional - Additional search parameters.

#### Request Body Options
- **pageLimit** (number) - Optional - The maximum number of pages to fetch. If set to 0, it fetches all available pages.
- **resolveReferences** (array) - Optional - An array of reference paths to resolve (e.g., `["subject", "performer"]`).
- **graph** (boolean) - Optional - If true, resolves references and mounts them into the resource tree. Defaults to false.

### Response
#### Success Response (200)
- **Bundle** (object) - A bundle containing fetched resources with resolved references.

### Request Example
```javascript
client.request("Observation?code=123", {
    pageLimit: 0,
    resolveReferences: [ "subject", "performer" ],
    graph: true
});
```
```

--------------------------------

### Remember Launch Parameters (EHR Launch)

Source: http://docs.smarthealthit.org/client-js/targets.html

In `launch.html`, capture launch parameters from the URL and persist them. This allows for delayed authorization in EHR launched apps.

```javascript
// in launch.html

// instead of authorizing directly, just remember the launch parameters
var searchParams = new URL(location.href).searchParams;
var launchParams = {
    launch: searchParams.get("launch"),
    iss   : searchParams.get("iss")
};
// Persist launchParams somewhere if needed

```

--------------------------------

### take

Source: http://docs.smarthealthit.org/client-js/typedoc/interfaces/types.fhirclient.RequestWithSession.html

Creates a new stream containing only the first specified number of chunks.

```APIDOC
## take

### Description
Returns a new stream containing the first limit chunks from the original stream.

### Parameters
- **limit** (number) - Required - The number of chunks to take.
- **options** (Pick<ArrayOptions, "signal">) - Optional - Configuration options.

### Returns
- **Readable** - A stream containing the taken chunks.
```

--------------------------------

### Initialize FhirClient

Source: http://docs.smarthealthit.org/client-js/fhir_client.html

Initialize a new FhirClient instance for browser or Node.js environments.

```javascript
const client = new FHIR.FhirClient("https://open-fhir-server.org");
```

```javascript
import FHIR from "fhirclient";

const client = new FHIR.FhirClient("https://open-fhir-server.org");
```

--------------------------------

### BrowserAdapter Methods

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/adapters_BrowserAdapter.default.html

Details the methods available on the BrowserAdapter class.

```APIDOC
## Methods

### atob
  * atob(str: string): string

  * ASCII string to Base64
#### Parameters
    * ##### str: string
#### Returns string

### base64urldecode
  * base64urldecode(input: string): string

  * Base64Url to ASCII string
#### Parameters
    * ##### input: string
#### Returns string

### base64urlencode
  * base64urlencode(input: string | Uint8Array): string

  * ASCII string or Uint8Array to Base64URL
#### Parameters
    * ##### input: string | Uint8Array
#### Returns string

### btoa
  * btoa(str: string): string

  * Base64 to ASCII string
#### Parameters
    * ##### str: string
#### Returns string

### getAbortController
  * getAbortController(): { prototype: AbortController }

  * Returns a reference to the AbortController constructor. In browsers, AbortController will always be available as global (native or polyfilled)
#### Returns { prototype: AbortController }
    * ##### prototype: AbortController

### getSmartApi
  * getSmartApi(): SMART

  * Creates and returns adapter-aware SMART api. Not that while the shape of the returned object is well known, the arguments to this function are not. Those who override this method are free to require any environment-specific arguments. For example in node we will need a request, a response and optionally a storage or storage factory function.
#### Returns SMART

### getStorage
  * getStorage(): default

  * Returns a BrowserStorage object which is just a wrapper around sessionStorage
#### Returns default

### getUrl
  * getUrl(): URL

  * Given the current environment, this method must return the current url as URL instance
#### Returns URL

### redirect
  * redirect(to: string): void

  * Given the current environment, this method must redirect to the given path
#### Parameters
    * ##### to: string
#### Returns void

### relative
  * relative(path: string): string

  * Given a relative path, returns an absolute url using the instance base URL
#### Parameters
    * ##### path: string
#### Returns string
```

--------------------------------

### FHIRClient Initialization and Usage

Source: http://docs.smarthealthit.org/client-js/typedoc/modules/entry_browser.html

Provides methods for creating a FHIRClient instance, handling OAuth2 authorization, and accessing utility functions within a browser environment.

```APIDOC
## FHIRClient Browser Entrypoint

This module exports an object that provides access to the FHIRClient, OAuth2 functionalities, and utility functions for browser-based applications.

### Variables

*   **`client`**: A function that creates and returns a `Client` instance.
    *   **Parameters**:
        *   `state` (string | ClientState) - The current state of the client.
    *   **Returns**: `default` - An instance of the FHIRClient.

*   **`oauth2`**: An object containing OAuth2 related functions.
    *   **`authorize`**: Initiates the SMART Launch Sequence.
        *   **Parameters**:
            *   `options` (AuthorizeParams) - Parameters for authorization, including `clientId`, `scope`, and optionally `iss` for standalone launch.
        *   **Returns**: `Promise<string | void>` - A promise that resolves with a string or void. **Note**: This function will redirect the user, so no subsequent code in the promise chain will execute.
    *   **`init`**: Initializes the FHIRClient in a single-page application.
        *   **Parameters**:
            *   `options` (AuthorizeParams) - Parameters for initialization, similar to `authorize`.
        *   **Returns**: `Promise<default>` - A promise that resolves with a `Client` instance after completing the authorization flow. **Note**: This function may be called twice due to redirects and requires careful handling of global side effects.
    *   **`ready`**: Prepares the FHIRClient for use, typically called on the `redirect_uri`.
        *   **Parameters**:
            *   `options` (ReadyOptions) - Optional parameters for readiness.
        *   **Returns**: `Promise<default>` - A promise that resolves with a `Client` instance.
    *   **`settings`**: Contains browser-specific FHIR settings (`BrowserFHIRSettings`).

*   **`utils`**: An object containing utility functions (any).
```

--------------------------------

### Update FHIR.oauth2.ready() with Callbacks (v1)

Source: http://docs.smarthealthit.org/client-js/migration

This is the older callback-style initialization for FHIR.oauth2.ready(). While acceptable in v2, the Promise-based approach is recommended.

```javascript
FHIR.oauth2.ready(onSuccess, onError);
```

--------------------------------

### Interface ReadyOptions

Source: http://docs.smarthealthit.org/client-js/typedoc/interfaces/types.fhirclient.ReadyOptions.html

Defines the configuration options for the ReadyOptions interface in FHIRClient v2.6.0.

```APIDOC
## Interface: ReadyOptions

### Description
Configuration options for the FHIRClient initialization process.

### Properties
- **clientPublicKeySetUrl** (string) - Optional - The URL for the client public key set.
- **code** (string) - Optional - The authorization code.
- **privateKey** (JWK | { alg: "ES384" | "RS384"; key: CryptoKey; kid: string }) - Optional - The private key used for authentication.
- **stateKey** (string) - Optional - The key used for state management.
```

--------------------------------

### SMART API Authorization

Source: http://docs.smarthealthit.org/client-js/api

The `authorize` method initiates the SMART Launch Sequence, which may involve redirecting the user to an authorization server. Any code following this call might not execute due to the redirect.

```APIDOC
## POST /oauth2/authorize

### Description
Starts the SMART Launch Sequence, potentially redirecting the user to an authorization server. Code following this call may not execute.

### Method
POST

### Endpoint
/oauth2/authorize

### Parameters
#### Query Parameters
- **clientId** (String) - Optional - The client ID obtained during app registration. Accepts `client_id` for backwards compatibility.
- **scope** (String) - Optional - One or more space-separated scopes to request.
- **clientSecret** (String) - Optional - The client secret for confidential clients. **Server-side only.** Accepts `client_secret` for backwards compatibility.
- **iss** (String) - Optional - The URL of the service to connect to. Required for Standalone Launch. **Do not provide for EHR Launch.**
- **redirectUri** (String) - Optional - The URI to redirect to after authorization. Defaults to the current directory root. Accepts `redirect_uri` for backwards compatibility.
- **pkceMode** (String) - Optional - Client expectations for PKCE. Options: "ifSupported" (default), "required", "disabled", "unsafeV1".
- **clientPrivateJwk** (Object) - Optional - The private JWK for confidential clients. **Server-side only.**
- **clientPublicKeySetUrl** (String) - Optional - The JWKS URL for confidential clients. **Server-side only.**

### Request Example
```json
{
  "clientId": "YOUR_CLIENT_ID",
  "scope": "launch openid profile",
  "iss": "https://your.fhir.server/"
}
```

### Response
This method initiates a redirect and returns a `Promise<never>`.
```

--------------------------------

### Initialize FHIR Client

Source: http://docs.smarthealthit.org/client-js/client.html

Instantiate the FHIR client for browser or server environments. Specify the FHIR server URL.

```javascript
// BROWSER
const client = FHIR.client("https://r4.smarthealthit.org");
```

```javascript
// SERVER
const client = smart(req, res).client("https://r4.smarthealthit.org");
```

--------------------------------

### Adapter Properties

Source: http://docs.smarthealthit.org/client-js/typedoc/interfaces/types.fhirclient.Adapter.html

Exposes configuration options and security-related utilities.

```APIDOC
## Adapter Properties

### options

`options: BrowserFHIRSettings`

Environment-specific options for the FHIR client.

### security

`security: { digestSha256: any; generatePKCEChallenge: any; importJWK: any; randomBytes: any; signCompactJws: any }`

Provides cryptographic utilities:

- **digestSha256**(payload: string): Promise<Uint8Array>
  Calculates the SHA-256 digest of a given payload.
- **generatePKCEChallenge**(entropy?: number): Promise<{ codeChallenge: string; codeVerifier: string }>
  Generates a PKCE code challenge and verifier.
- **importJWK**(jwk: JWK): Promise<CryptoKey>
  Imports a JWK into a CryptoKey.
- **randomBytes**(count: number): Uint8Array
  Generates cryptographically secure random bytes.
- **signCompactJws**(alg: "ES384" | "RS384", privateKey: CryptoKey, header: any, payload: any): Promise<string>
  Signs a JWS using compact serialization.
```

--------------------------------

### Constructor - default

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/storage_ServerStorage.default.html

Initializes a new instance of the default class. It requires a RequestWithSession object which must contain a session property.

```APIDOC
## constructor new default(request: RequestWithSession): default

### Description
Initializes a new instance of the default class.

### Parameters
#### request: RequestWithSession
The HTTP request that is expected to have a "session" object property.

### Returns
default
```

--------------------------------

### Fetch All Resources

Source: http://docs.smarthealthit.org/client-js/fhirjs-equivalents.html

Fetches all resources of a given type, handling pagination.

```APIDOC
## GET ResourceType?optional-query (with pagination)

### Description
Fetches all resources of a specified type, automatically handling pagination up to the specified page limit.

### Method
GET

### Endpoint
`ResourceType?optional-query`

### Parameters
#### Path Parameters
- **ResourceType** (string) - Required - The type of FHIR resource to fetch.

#### Query Parameters
- **optional-query** (string) - Optional - Additional search parameters.

#### Request Body Options
- **pageLimit** (number) - Optional - The maximum number of pages to fetch. If set to 0, it fetches all available pages.

### Response
#### Success Response (200)
- **Bundle** (object) - A bundle containing all fetched resources.

### Request Example
```javascript
client.request("Observation?code=123", {
    pageLimit: 0 // Fetches all pages
});
```
```

--------------------------------

### Authorize in a Popup Window

Source: http://docs.smarthealthit.org/client-js/targets.html

Use the `target: "popup"` option to initiate the authorization flow in a new popup window. The main window will load the `redirect_uri` upon successful authorization.

```javascript
FHIR.oauth2.authorize({
    target: "popup",
    // ...
});

```

--------------------------------

### Initialize FHIR Client

Source: http://docs.smarthealthit.org/client-js/typedoc/classes/Client.default.html

Create a new FHIR client instance for either browser or server environments.

```javascript
// BROWSER  
const client = FHIR.client("https://r4.smarthealthit.org");  
  
// SERVER  
const client = smart(req, res).client("https://r4.smarthealthit.org");
```

--------------------------------

### Loading HAPI Adapter for client-js

Source: http://docs.smarthealthit.org/client-js/node.html

To use the HAPI adapter, import the `smart` function from `fhirclient/lib/entry/hapi`. This provides an adapter tailored for the HAPI framework.

```javascript
// NOTE
// require("fhirclient/lib/entry/hapi") is the same as require("fhirclient/lib/adapters/HapiAdapter").default.smart;
// but it is cleaner and comes with proper type definitions
const smart = require("fhirclient/lib/entry/hapi");


// inside your redirect_uri route handler
smart(request, h).ready(client => client.request("Patient"));
```

--------------------------------

### Initialize FHIR Client with init()

Source: http://docs.smarthealthit.org/client-js/api

Use `init()` for a single-page authorization flow where the launch URI matches the redirect URI. This method internally calls `authorize` and then `ready`. Ensure all app code executes only after the `init()` promise resolves.

```javascript
FHIR.oauth2.init({
    client_id: "my_web_app",
    scope    : "patient/*.read"
}).then(client => /* initialize my app */);
```

--------------------------------

### FetchOptions Interface

Source: http://docs.smarthealthit.org/client-js/typedoc/interfaces/types.fhirclient.FetchOptions.html

The FetchOptions interface extends RequestInit and provides additional options for configuring HTTP requests within the FHIRClient. These options mirror the standard Web Fetch API but are tailored for FHIR interactions.

```APIDOC
## Interface FetchOptions

Options passed to the lib.request function.

### Hierarchy
  * RequestInit
    * FetchOptions

### Properties

#### Optional body
`body?: null | BodyInit`
A BodyInit object or null to set request's body.

#### Optional cache
`cache?: RequestCache`
A string indicating how the request will interact with the browser's cache to set request's cache.

#### Optional credentials
`credentials?: RequestCredentials`
A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials.

#### Optional headers
`headers?: HeadersInit`
A Headers object, an object literal, or an array of two-item arrays to set request's headers.

#### Optional includeResponse
`includeResponse?: boolean`
If `true` the request function will be instructed to resolve with a CombinedFetchResult object that contains the `Response` object abd the parsed body (if any).

#### Optional integrity
`integrity?: string`
A cryptographic hash of the resource to be fetched by request. Sets request's integrity.

#### Optional keepalive
`keepalive?: boolean`
A boolean to set request's keepalive.

#### Optional method
`method?: string`
A string to set request's method.

#### Optional mode
`mode?: RequestMode`
A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.

#### Optional redirect
`redirect?: RequestRedirect`
A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect.

#### Optional referrer
`referrer?: string`
A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.

#### Optional referrerPolicy
`referrerPolicy?: ReferrerPolicy`
A referrer policy to set request's referrerPolicy.

#### Optional signal
`signal?: null | AbortSignal`
An AbortSignal to set request's signal.

#### Optional window
`window?: null`
Can only be null. Used to disassociate request from any Window.
```

--------------------------------

### Adapter Methods

Source: http://docs.smarthealthit.org/client-js/typedoc/interfaces/types.fhirclient.Adapter.html

Provides utility functions for encoding/decoding, environment interaction, and API access.

```APIDOC
## Adapter Methods

### atob

`atob(str: string): string`

Converts an ASCII string to Base64.

### base64urldecode

`base64urldecode(input: string): string`

Decodes a Base64Url string to an ASCII string.

### base64urlencode

`base64urlencode(input: string | Uint8Array): string`

Encodes an ASCII string or Uint8Array to Base64URL.

### btoa

`btoa(str: string): string`

Converts a Base64 string to an ASCII string.

### getAbortController

`getAbortController(): { prototype: AbortController }`

Returns a reference to the AbortController class.

### getSmartApi

`getSmartApi(): SMART`

Creates and returns an adapter-aware SMART API instance.

### getStorage

`getStorage(): Storage`

Returns the environment's Storage object.

### getUrl

`getUrl(): URL`

Returns the current URL as a URL instance.

### redirect

`redirect(to: string): void | Promise<any>`

Redirects the client to the specified path.

### relative

`relative(path: string): string`

Computes the full URL for a given relative path.
```

--------------------------------

### Create Resource using client.create()

Source: http://docs.smarthealthit.org/client-js/migration

Use the convenience wrapper client.create() for FHIR create operations, passing the resource object directly.

```javascript
client.create(resource)
```

--------------------------------

### NPM development scripts

Source: http://docs.smarthealthit.org/client-js/typedoc/index.html

Commonly used scripts for testing, building, and packaging the library.

```bash
# run tests  
npm test  
  
# Build everything  
npm run build  
  
# Build all bundles (browser packages in dist/build)  
npm run pack  
  
# Build the CommonJS modules (for Node and bundlers)  
npm run build:module
```

--------------------------------

### Fetch All Resources

Source: http://docs.smarthealthit.org/client-js/fhirjs-equivalents.html

Retrieve all pages of a search result.

```javascript
client.request("ResourceType?optional-query", {
    pageLimit: 0
})
```

--------------------------------

### Create FHIR Client Instance

Source: http://docs.smarthealthit.org/client-js

Initialize a FHIR client instance for direct server interaction without authorization.

```javascript
// BROWSER
const client = FHIR.client({
    serverUrl: "https://r4.smarthealthit.org"
});

// SERVER
const client = fhirClient(req, res).client({
    serverUrl: "https://r4.smarthealthit.org"
});
```

--------------------------------

### authorize(options)

Source: http://docs.smarthealthit.org/client-js/node.html

Initiates the OAuth2 authorization flow. This method should be called within your application's launch_uri route handler.

```APIDOC
## authorize(options)

### Description
Initiates the OAuth2 authorization flow. This method should be called within your application's launch_uri route handler.

### Method
POST

### Endpoint
`/your_launch_uri`

### Parameters
#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const smart = require("fhirclient");

// inside your launch_uri route handler
smart(request, response).authorize({
    "client_id": "my_web_app",
    "scope"    : "launch patient/*.read openid fhirUser"
});
```

### Response
#### Success Response (302 Redirect)
Redirects the user to the authorization server.

#### Response Example
None (handled by redirect)
```

--------------------------------

### Enable Debug Logging

Source: http://docs.smarthealthit.org/client-js

Configure debug logging for the library in Node.js and browser environments.

```bash
DEBUG='FHIR.*' node my-app
```

```javascript
localStorage.debug = "FHIR.*"
```

--------------------------------

### Update FHIR.oauth2.ready() to use Promises

Source: http://docs.smarthealthit.org/client-js/migration

Migrate from callback-based initialization to Promise-based initialization with FHIR.oauth2.ready(). onError will now receive a single Error instance.

```javascript
FHIR.oauth2.ready().then(onSuccess).catch(onError);
```
Tokens:
Raw