diff --git a/README.md b/README.md
index ed0f622..42ede90 100644
--- a/README.md
+++ b/README.md
@@ -255,11 +255,11 @@ Aidbox subscription is a way to subscribe and get notifications about updating r
 our [subscription sample](https://github.com/Aidbox/aidbox-sdk-js/tree/main/subscription-sample) for more details.
 
 ```javascript
-await client.createSubscription({
+await client.subsSubscription.create({
   id: 'patient-created',
   status: 'active',
   trigger: { Patient: { event: ['create'] } },
-  channel: { endpoint: `${process.env.NODE_APP_URL}/patient-created` },
+  channel: { endpoint: 'https://aidbox/patient-created' },
 });
 ```
 
diff --git a/vendor/r4/README.md b/vendor/r4/README.md
new file mode 100644
index 0000000..842b197
--- /dev/null
+++ b/vendor/r4/README.md
@@ -0,0 +1,395 @@
+# Aidbox JavaScript SDK FHIR-R4
+
+## How to use
+
+**Important:** Before we start we have to make sure that
+aidbox [client](https://docs.aidbox.app/tutorials/security-and-access-control/basic-auth-tutorial#basic-auth) is
+configured
+and your [access policies](https://docs.aidbox.app/security-and-access-control-1/security/access-control) provide
+granular access to resources you're trying to reach.
+
+```javascript
+import { Client } from 'aidbox-sdk';
+
+export const aidbox = new Client('<HOST_URL>', {
+  auth: {
+    method: 'basic',
+    credentials: {
+      username: '<CLIENT_NAME>',
+      password: '<CLIENT_SECRET>',
+    },
+  },
+});
+```
+
+This code creates a new instance of the SDK from the aidbox-sdk package, and sets it up to connect to an Aidbox server
+running on `<HOST_URL>`.
+You would need to replace `<CLIENT_NAME>` and `<CLIENT_SECRET>` with the actual client ID and client secret that you
+configured earlier, also SDK support two types of API (Aidbox,
+FHIR [see difference](https://docs.aidbox.app/modules-1/fhir-resources/aidbox-and-fhir-formats)) just provide one of
+them as third parameter.
+
+By using aidbox-sdk in your project, you can easily interact with an Aidbox server and perform actions like reading and
+writing resources, searching for resources, and more.
+
+Then you can use aidboxClient in wherever you want
+
+```javascript
+import { aidbox } from '../aidbox-client';
+
+async function getPatients() {
+  return aidbox.resource.list('Patient');
+}
+```
+
+## API
+
+### resource.list
+
+list method accepts the name of the resource and is the basis for the subsequent complication of the request
+
+#### where
+
+Method where add additional parameters for searching
+
+For example, you want to find all patients with name John, so
+
+```typescript
+resource.list('Patient').where('name', 'John');
+```
+
+Or, you want to find all patients with name John or Steve
+
+```typescript
+resource.list('Patient').where('name', ['John', 'Steve']);
+```
+
+Also, method where support prefixes for numbers and date, just pass it as third parameter
+
+```typescript
+resource.list('Patient').where('birthDate', '2014-06-30', 'gt');
+```
+
+#### Sort
+
+Method sort add additional parameters for sorting
+
+For example, you want to display the oldest patients
+
+```typescript
+resource.list('Patient').sort('birthDate', 'acs');
+```
+
+And also, you want to sort this data by patients name
+
+```typescript
+resource.list('Patient').sort('birthDate', 'acs').sort('name', 'acs');
+```
+
+#### Count
+
+Method count used for make limit the number of resource returned by request
+
+```typescript
+resource.list('Patient').count(10);
+```
+
+#### Summary
+
+To request only a portion of the resources from a server, you can use the summary function. This function allows you to
+specify the type of summary you want to receive, such as **true, false, text, data, or count**.
+
+By default, when you make a request to a server, it will return all resource.
+
+The summary function accepts several types of summaries, each of which provides a different level of detail about the
+data. For example:
+
+- true - limited subset of elements from the resource
+- false - all parts of the resource
+- text - only the text, id, meta, and top-level mandatory elements
+- data - resources without the text element
+- count - count of the matching resources, without returning the actual matches
+
+  summary("data")
+
+#### Elements
+
+If you need to retrieve specific elements of a resource from a server, you can use the elements function. This function
+allows you to specify which parts of the resource you are interested in, and can help to reduce the amount of data
+returned by the server.
+
+By using the elements function, you can customize your requests to retrieve only the data that you need, rather than
+requesting the entire dataset. This can be particularly useful when dealing with large datasets or when you only need a
+small subset of the available data.
+
+To use the elements function, simply pass in the elements you want to retrieve as arguments. For example, if you only
+need the name and address fields from a resource, you can make a request using the following syntax:
+
+```typescript
+resource.list('Patient').elements(['name', 'address']);
+```
+
+This request will return only the name and address fields for each resource, rather than the entire dataset. By reducing
+the amount of data returned, you can help to streamline your requests and improve the performance of your application.
+
+### resource.get
+
+The get function is a tool for retrieving a single resource by its ID.
+
+To use the getResource function, you must pass in the resource type and ID as arguments. For example, if you want to
+retrieve a patient resource with the ID some-id, you can make a request using the following syntax:
+
+```typescript
+resource.get('Patient', 'id');
+```
+
+### resource.create
+
+The createResource function is used to create a new resource.
+
+The first argument is a resource name, the second one is body of resource
+
+```typescript
+resource.create('Patient', { active: true });
+```
+
+### resource.update()
+
+The update function is used to update a specific resource identified by its id with a partial set of data
+provided in the third parameter. This function allows for partial updates of a resource without having to send the
+entire resource object.
+
+The first parameter specifies the name of the resource to be updated. The second parameter identifies the specific
+resource to be updated.
+
+```typescript
+resource.update('Patient', 'c58f29eb-f28d-67c1-0400-9af3aba3d58c', {
+  active: false,
+});
+```
+
+### ### resource.delete()
+
+The deleteResource function is used to delete a specific resource identified by its id.
+
+```typescript
+resource.delete('Patient', 'c58f29eb-f28d-67c1-0400-9af3aba3d58c');
+```
+
+### createSubscription
+
+Aidbox subscription is a way to subscribe and get notifications about updating resources on the server. See
+our [subscription sample](https://github.com/Aidbox/aidbox-sdk-js/tree/main/subscription-sample) for more details.
+
+```javascript
+await client.subsSubscription.create({
+  id: 'patient-created',
+  status: 'active',
+  trigger: { Patient: { event: ['create'] } },
+  channel: { endpoint: 'https://aidbox/patient-created' },
+});
+```
+
+### sendLog
+
+Aidbox has the ability to extend its logs. There is
+an [endpoint](https://docs.aidbox.app/core-modules/logging-and-audit/extending-access-logs#usdloggy-endpoint) that
+accepts logs with the defined structure from your application. These logs are ingested into the elastic log.
+
+```javascript
+await client.sendLog({
+    type: "ui",
+    message: {event: "YOUR_EVENT", id: "id", ...},
+    v: "APP_VERSION",
+    fx: "fetchUsers"
+})
+```
+
+### Bundle request
+
+SDK has helpers to prepare data for bundle request.
+
+```javascript
+client.transformToBundle(
+  [
+    {
+      resourceType: 'Patient',
+      name: [
+        {
+          given: [''],
+          family: '',
+        },
+      ],
+    },
+  ],
+  'POST',
+);
+```
+
+Bundle requests could be a [transaction or batch](https://docs.aidbox.app/api-1/fhir-api/bundle#post-endpoint) type. SDK
+uses the "transaction" type by default but you can change it by providing it in the second parameter.
+
+```javascript
+const data = ArrayOfPatients.map(client.bundleEntryPost);
+
+await client.bundleRequest(data, 'batch');
+```
+
+## Task API
+
+Queues are a valuable tool for achieving reliable, asynchronous, scalable, and retry-safe code execution.
+By using queues, we can ensure that tasks or messages are processed reliably, even in the face of failures or system
+disruptions.
+The asynchronous nature of queues allows tasks to be processed independently, enabling parallelism and reducing wait
+times.
+
+```javascript
+import { Engine } from 'aidbox-javascript-sdk';
+
+const client = new Engine('http://localhost:8888', {
+  username: 'test',
+  password: 'secret',
+});
+```
+
+### Definition
+
+First of all we have to create task's schema with settings that apply restrictions on
+input and output arguments for entity like this one:
+
+```clojure
+ SendMessage
+{:zen/tags #{awf.task/definition zen/schema}
+ :type     zen/map
+ :keys     {:params {:type    zen/map
+                     :require #{:phone :message}
+                     :keys    {:phone   {:type zen/string}
+                               :message {:type zen/string}}}
+            :result {:type    zen/map
+                     :require #{:status}
+                     :keys    {:status {:type zen/string}}}}}
+```
+
+[More information about task definition](https://docs.aidbox.app/modules-1/workflow-engine/task#1.-specify-task-definition)  
+Notice: we have to regenerate SDK package each time we made changes into configuration project
+
+### Implementation
+
+Next step is creating business logic that will be considered as a worker,
+the worker will be handling each task, we can
+
+```javascript
+client.task.implement(
+  'SendMessage',
+  async ({ params, status }) => {
+    const { message, phone } = params;
+
+    try {
+      await fetch('https://message-sending-server.com/', {
+        method: 'POST',
+        body: JSON.stringify({ message, phone }),
+      });
+
+      return { status: 'success' };
+    } catch (error) {
+      return { status: 'failure' };
+    }
+  },
+  { batchSize: 5 },
+);
+```
+
+### Execution
+
+The way to execute a single task with unique context
+
+```javascript
+await client.task.execute('SendMessage', {
+  phone: '+1234567890',
+  message: 'Hi!',
+});
+```
+
+## Workflow Engine
+
+Aidbox provides Workflow Engine module, so you're able to define your own sequence
+of async tasks on top of Task API. In many business processes, certain tasks depend on the completion of other tasks.
+Defining task dependencies through workflow implementation allows the developer
+to control the order in which tasks are executed.
+
+```javascript
+import { Engine } from 'aidbox-javascript-sdk';
+
+const client = new Engine('http://localhost:8888', {
+  username: 'test',
+  password: 'secret',
+});
+```
+
+### Workflow Definition
+
+```clojure
+ CheckOutWorkflow
+{:zen/tags #{awf.workflow/definition zen/schema}
+ :type     zen/map
+ :pool     decision-pool
+ :keys     {:params {:type    zen/map
+                     :require #{:clientId}
+                     :keys    {:clientId {:type zen/string}}}
+            :result {:type zen/map
+                     :keys {:messageId {:type zen/string}}}
+            :error  {:type zen/map
+                     :keys {:message {:type zen/string}}}}}
+```
+
+[More information about workflow definition](https://docs.aidbox.app/modules-1/workflow-engine/workflow#1.-specify-workflow-definition)  
+Notice: we have to regenerate SDK package each time we made changes into configuration project
+
+### Workflow Implementation
+
+```javascript
+await client.workflow.implement(
+  'CheckOutWorkflow',
+  async ({ params }, { execute, complete, fail }) => {
+    if (params.event === 'awf.workflow.event/workflow-init') {
+      const response = await fetch('https://server.com/get-client');
+      const { phone } = response.json();
+      return [
+        execute({
+          definition: 'SendMessage',
+          params: { phone, message: 'Hi!' },
+        }),
+      ];
+    }
+
+    try {
+      const response = await fetch('https://workflow-state.com');
+      const data = response.json();
+
+      if (
+        params.event === 'awf.workflow.event/task-completed' &&
+        data.step === 1
+      ) {
+        return [execute({ definition: 'UpdateInformation', params: {} })];
+      }
+
+      if (
+        params.event === 'awf.workflow.event/task-completed' &&
+        data.step === 2
+      ) {
+        return [complete({})];
+      }
+    } catch (error) {
+      return [fail({ error })];
+    }
+
+    return [];
+  },
+);
+```
+
+### Workflow Execution
+
+```javascript
+await client.workflow.execute('CheckOutWorkflow', { clientId: '' });
+```
diff --git a/vendor/r4/http-client.d.ts b/vendor/r4/http-client.d.ts
new file mode 100644
index 0000000..d9dc971
--- /dev/null
+++ b/vendor/r4/http-client.d.ts
@@ -0,0 +1,405 @@
+export type RetryOptions = {
+    /**
+    The number of times to retry failed requests.
+
+    @default 2
+    */
+    limit?: number;
+    /**
+    The HTTP methods allowed to retry.
+
+    @default ['get', 'put', 'head', 'delete', 'options', 'trace']
+    */
+    methods?: string[];
+    /**
+    The HTTP status codes allowed to retry.
+
+    @default [408, 413, 429, 500, 502, 503, 504]
+    */
+    statusCodes?: number[];
+    /**
+    The HTTP status codes allowed to retry with a `Retry-After` header.
+
+    @default [413, 429, 503]
+    */
+    afterStatusCodes?: number[];
+    /**
+    If the `Retry-After` header is greater than `maxRetryAfter`, the request will be canceled.
+
+    @default Infinity
+    */
+    maxRetryAfter?: number;
+    /**
+    The upper limit of the delay per retry in milliseconds.
+    To clamp the delay, set `backoffLimit` to 1000, for example.
+
+    By default, the delay is calculated in the following way:
+
+    ```
+    0.3 * (2 ** (attemptCount - 1)) * 1000
+    ```
+
+    The delay increases exponentially.
+
+    @default Infinity
+    */
+    backoffLimit?: number;
+};
+export declare function composeAbortError(signal?: AbortSignal): Error | DOMException;
+export declare class HTTPError extends Error {
+    response: Response;
+    request: Request;
+    options: NormalizedOptions;
+    constructor(response: Response, request: Request, options: NormalizedOptions);
+}
+export declare class TimeoutError extends Error {
+    request: Request;
+    constructor(request: Request);
+}
+export type DelayOptions = {
+    signal?: InternalOptions['signal'];
+};
+export declare function delay(ms: number, { signal }: DelayOptions): Promise<void>;
+export declare const isObject: (value: unknown) => value is object;
+export declare const validateAndMerge: (...sources: Array<Partial<Options> | undefined>) => Partial<Options>;
+export declare const mergeHeaders: (source1?: HttpClientHeadersInit, source2?: HttpClientHeadersInit) => Headers;
+export declare const deepMerge: <T>(...sources: (Partial<T> | undefined)[]) => T;
+export declare const normalizeRequestMethod: (input: string) => string;
+export declare const normalizeRetryOptions: (retry?: number | RetryOptions) => Required<RetryOptions>;
+export type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type ObjectEntries<T> = T extends ArrayLike<infer U> ? Array<[string, U]> : Array<{
+    [K in keyof T]: [K, T[K]];
+}[keyof T]>;
+export type TimeoutOptions = {
+    timeout: number;
+    fetch: typeof fetch;
+};
+export declare function timeout(request: Request, abortController: AbortController | undefined, options: TimeoutOptions): Promise<Response>;
+export type ResponsePromise = {
+    arrayBuffer: () => Promise<ArrayBuffer>;
+    blob: () => Promise<Blob>;
+    formData: () => Promise<FormData>;
+    /**
+    Get the response body as JSON.
+    */
+    json: <T = unknown>() => Promise<T>;
+    text: () => Promise<string>;
+} & Promise<HttpClientResponse>;
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+export type Required<T, K extends keyof T = keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type LiteralUnion<LiteralType extends BaseType, BaseType extends Primitive> = LiteralType | (BaseType & {
+    _?: never;
+});
+export type HttpClientResponse = {
+    json: <T = unknown>() => Promise<T>;
+} & Response;
+export declare const supportsRequestStreams: boolean;
+export declare const supportsAbortController: boolean;
+export declare const supportsResponseStreams: boolean;
+export declare const supportsFormData: boolean;
+export declare const requestMethods: readonly ["get", "post", "put", "patch", "head", "delete"];
+export declare const responseTypes: {
+    readonly json: "application/json";
+    readonly text: "text/*";
+    readonly formData: "multipart/form-data";
+    readonly arrayBuffer: "*/*";
+    readonly blob: "*/*";
+};
+export declare const maxSafeTimeout = 2147483647;
+export declare const stop: unique symbol;
+export type HttpClientInstance = {
+    /**
+    Fetch the given `url`.
+
+    @param url - `Request` object, `URL` object, or URL string.
+    @returns A promise with `Body` method added.
+
+    */
+    (url: Input, options?: Options): ResponsePromise;
+    /**
+    Fetch the given `url` using the option `{method: 'get'}`.
+
+    @param url - `Request` object, `URL` object, or URL string.
+    @returns A promise with `Body` methods added.
+    */
+    get: (url: Input, options?: Options) => ResponsePromise;
+    /**
+    Fetch the given `url` using the option `{method: 'post'}`.
+
+    @param url - `Request` object, `URL` object, or URL string.
+    @returns A promise with `Body` methods added.
+    */
+    post: (url: Input, options?: Options) => ResponsePromise;
+    /**
+    Fetch the given `url` using the option `{method: 'put'}`.
+
+    @param url - `Request` object, `URL` object, or URL string.
+    @returns A promise with `Body` methods added.
+    */
+    put: (url: Input, options?: Options) => ResponsePromise;
+    /**
+    Fetch the given `url` using the option `{method: 'delete'}`.
+
+    @param url - `Request` object, `URL` object, or URL string.
+    @returns A promise with `Body` methods added.
+    */
+    delete: (url: Input, options?: Options) => ResponsePromise;
+    /**
+    Fetch the given `url` using the option `{method: 'patch'}`.
+
+    @param url - `Request` object, `URL` object, or URL string.
+    @returns A promise with `Body` methods added.
+    */
+    patch: (url: Input, options?: Options) => ResponsePromise;
+    /**
+    Fetch the given `url` using the option `{method: 'head'}`.
+
+    @param url - `Request` object, `URL` object, or URL string.
+    @returns A promise with `Body` methods added.
+    */
+    head: (url: Input, options?: Options) => ResponsePromise;
+    /**
+    Create a new  instance with complete new defaults.
+
+    @returns A new client instance.
+    */
+    create: (defaultOptions: Options) => HttpClientInstance;
+    /**
+    Create a new client instance with some defaults overridden with your own.
+
+    In contrast to `client.create()`, `client.extend()` inherits defaults from its parent.
+
+    @returns A new client instance.
+    */
+    extend: (defaultOptions: Options) => HttpClientInstance;
+    /**
+    A `Symbol` that can be returned by a `beforeRetry` hook to stop the retry. This will also short circuit the remaining `beforeRetry` hooks.
+
+    Note: Returning this symbol makes client abort and return with an `undefined` response. Be sure to check for a response before accessing any properties on it or use [optional chaining](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining). It is also incompatible with body methods, such as `.json()` or `.text()`, because there is no response to parse. In general, we recommend throwing an error instead of returning this symbol, as that will cause client to abort and then throw, which avoids these limitations.
+
+    A valid use-case for `client.stop` is to prevent retries when making requests for side effects, where the returned data is not important. For example, logging client activity to the server.
+
+    */
+    readonly stop: typeof stop;
+};
+export type BeforeRequestHook = (request: Request, options: NormalizedOptions) => Request | Response | void | Promise<Request | Response | void>;
+export type BeforeRetryState = {
+    request: Request;
+    options: NormalizedOptions;
+    error: Error;
+    retryCount: number;
+};
+export type BeforeRetryHook = (options: BeforeRetryState) => typeof stop | void | Promise<typeof stop | void>;
+export type AfterResponseHook = (request: Request, options: NormalizedOptions, response: Response) => Response | void | Promise<Response | void>;
+export type BeforeErrorHook = (error: HTTPError) => HTTPError | Promise<HTTPError>;
+export type Hooks = {
+    /**
+    This hook enables you to modify the request right before it is sent. client will make no further changes to the request after this. The hook function receives normalized input and options as arguments. You could, forf example, modiy `options.headers` here.
+
+    A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) can be returned from this hook to completely avoid making a HTTP request. This can be used to mock a request, check an internal cache, etc. An **important** consideration when returning a `Response` from this hook is that all the following hooks will be skipped, so **ensure you only return a `Response` from the last hook**.
+
+    @default []
+    */
+    beforeRequest?: BeforeRequestHook[];
+    /**
+    This hook enables you to modify the request right before retry. client will make no further changes to the request after this. The hook function receives an object with the normalized request and options, an error instance, and the retry count. You could, for example, modify `request.headers` here.
+
+    If the request received a response, the error will be of type `HTTPError` and the `Response` object will be available at `error.response`. Be aware that some types of errors, such as network errors, inherently mean that a response was not received. In that case, the error will not be an instance of `HTTPError`.
+
+    You can prevent client from retrying the request by throwing an error. client will not handle it in any way and the error will be propagated to the request initiator. The rest of the `beforeRetry` hooks will not be called in this case. Alternatively, you can return the [`client.stop`](#client.stop) symbol to do the same thing but without propagating an error (this has some limitations, see `client.stop` docs for details).
+
+    @default []
+    */
+    beforeRetry?: BeforeRetryHook[];
+    /**
+    This hook enables you to read and optionally modify the response. The hook function receives normalized input, options, and a clone of the response as arguments. The return value of the hook function will be used by client as the response object if it's an instance of [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).
+
+    @default []
+
+    */
+    afterResponse?: AfterResponseHook[];
+    /**
+    This hook enables you to modify the `HTTPError` right before it is thrown. The hook function receives a `HTTPError` as an argument and should return an instance of `HTTPError`.
+
+    @default []
+
+    @example
+    ```
+    import client from 'client';
+
+    await client('https://example.com', {
+        hooks: {
+            beforeError: [
+                error => {
+                    const {response} = error;
+                    if (response && response.body) {
+                        error.name = 'GitHubError';
+                        error.message = `${response.body.message} (${response.status})`;
+                    }
+
+                    return error;
+                }
+            ]
+        }
+    });
+    ```
+    */
+    beforeError?: BeforeErrorHook[];
+};
+export type SearchParamsInit = string | string[][] | Record<string, string> | URLSearchParams | undefined;
+export type SearchParamsOption = SearchParamsInit | Record<string, string | number | boolean> | Array<Array<string | number | boolean>>;
+export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete';
+export type Input = string | URL | Request;
+export type DownloadProgress = {
+    percent: number;
+    transferredBytes: number;
+    /**
+    Note: If it's not possible to retrieve the body size, it will be `0`.
+    */
+    totalBytes: number;
+};
+export type HttpClientHeadersInit = HeadersInit | Record<string, string | undefined>;
+/**
+Options are the same as `window.fetch`, with some exceptions.
+*/
+export type Options = {
+    /**
+    HTTP method used to make the request.
+
+    Internally, the standard methods (`GET`, `POST`, `PUT`, `PATCH`, `HEAD` and `DELETE`) are uppercased in order to avoid server errors due to case sensitivity.
+    */
+    method?: LiteralUnion<HttpMethod, string>;
+    /**
+    HTTP headers used to make the request.
+
+    You can pass a `Headers` instance or a plain object.
+
+    You can remove a header with `.extend()` by passing the header with an `undefined` value.
+
+    ```
+    */
+    headers?: HttpClientHeadersInit;
+    /**
+    Shortcut for sending JSON. Use this instead of the `body` option.
+
+    Accepts any plain object or value, which will be `JSON.stringify()`'d and sent in the body with the correct header set.
+    */
+    json?: unknown;
+    /**
+    User-defined JSON-parsing function.
+
+    Use-cases:
+    1. Parse JSON via the [`bourne` package](https://github.com/hapijs/bourne) to protect from prototype pollution.
+    2. Parse JSON with [`reviver` option of `JSON.parse()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse).
+
+    @default JSON.parse()
+
+    ```
+    */
+    parseJson?: (text: string) => unknown;
+    /**
+    Search parameters to include in the request URL. Setting this will override all existing search parameters in the input URL.
+
+    Accepts any value supported by [`URLSearchParams()`](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams/URLSearchParams).
+    */
+    searchParams?: SearchParamsOption;
+    /**
+    A prefix to prepend to the `input` URL when making the request. It can be any valid URL, either relative or absolute. A trailing slash `/` is optional and will be added automatically, if needed, when it is joined with `input`. Only takes effect when `input` is a string. The `input` argument cannot start with a slash `/` when using this option.
+
+    Useful when used with [`client.extend()`](#clientextenddefaultoptions) to create niche-specific client-instances.
+
+    Notes:
+     - After `prefixUrl` and `input` are joined, the result is resolved against the [base URL](https://developer.mozilla.org/en-US/docs/Web/API/Node/baseURI) of the page (if any).
+     - Leading slashes in `input` are disallowed when using this option to enforce consistency and avoid confusion about how the `input` URL is handled, given that `input` will not follow the normal URL resolution rules when `prefixUrl` is being used, which changes the meaning of a leading slash.
+
+    */
+    prefixUrl?: URL | string;
+    /**
+    An object representing `limit`, `methods`, `statusCodes` and `maxRetryAfter` fields for maximum retry count, allowed methods, allowed status codes and maximum [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time.
+
+    If `retry` is a number, it will be used as `limit` and other defaults will remain in place.
+
+    If `maxRetryAfter` is set to `undefined`, it will use `options.timeout`. If [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header is greater than `maxRetryAfter`, it will cancel the request.
+
+    Delays between retries is calculated with the function `0.3 * (2 ** (retry - 1)) * 1000`, where `retry` is the attempt number (starts from 1).
+
+    Retries are not triggered following a timeout.
+
+    */
+    retry?: RetryOptions | number;
+    /**
+    Timeout in milliseconds for getting a response, including any retries. Can not be greater than 2147483647.
+    If set to `false`, there will be no timeout.
+
+    @default 10000
+    */
+    timeout?: number | false;
+    /**
+    Hooks allow modifications during the request lifecycle. Hook functions may be async and are run serially.
+    */
+    hooks?: Hooks;
+    /**
+    Throw an `HTTPError` when, after following redirects, the response has a non-2xx status code. To also throw for redirects instead of following them, set the [`redirect`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters) option to `'manual'`.
+
+    Setting this to `false` may be useful if you are checking for resource availability and are expecting error responses.
+
+    Note: If `false`, error responses are considered successful and the request will not be retried.
+
+    @default true
+    */
+    throwHttpErrors?: boolean;
+    /**
+    Download progress event handler.
+
+    @param chunk - Note: It's empty for the first call.
+
+    */
+    onDownloadProgress?: (progress: DownloadProgress, chunk: Uint8Array) => void;
+    /**
+    User-defined `fetch` function.
+    Has to be fully compatible with the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) standard.
+
+    Use-cases:
+    1. Use custom `fetch` implementations like [`isomorphic-unfetch`](https://www.npmjs.com/package/isomorphic-unfetch).
+    2. Use the `fetch` wrapper function provided by some frameworks that use server-side rendering (SSR).
+
+    @default fetch
+
+    */
+    fetch?: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+} & Omit<RequestInit, 'headers'>;
+export type InternalOptions = Required<Omit<Options, 'hooks' | 'retry'>, 'credentials' | 'fetch' | 'prefixUrl' | 'timeout'> & {
+    headers: Required<Headers>;
+    hooks: Required<Hooks>;
+    retry: Required<RetryOptions>;
+    prefixUrl: string;
+};
+/**
+Normalized options passed to the `fetch` call and the `beforeRequest` hooks.
+*/
+export type NormalizedOptions = {
+    method: RequestInit['method'];
+    credentials: RequestInit['credentials'];
+    retry: RetryOptions;
+    prefixUrl: string;
+    onDownloadProgress: Options['onDownloadProgress'];
+} & RequestInit;
+export declare class HttpClient {
+    static create(input: Input, options: Options): ResponsePromise;
+    request: Request;
+    protected abortController?: AbortController;
+    protected _retryCount: number;
+    protected _input: Input;
+    protected _options: InternalOptions;
+    constructor(input: Input, options?: Options);
+    protected _calculateRetryDelay(error: unknown): number;
+    protected _decorateResponse(response: Response): Response;
+    protected _retry<T extends (...args: any) => Promise<any>>(fn: T): Promise<ReturnType<T> | void>;
+    protected _fetch(): Promise<Response>;
+    protected _stream(response: Response, onDownloadProgress: Options['onDownloadProgress']): Response;
+}
+export declare const httpClient: HttpClientInstance;
diff --git a/vendor/r4/http-client.js b/vendor/r4/http-client.js
new file mode 100644
index 0000000..6bacac0
--- /dev/null
+++ b/vendor/r4/http-client.js
@@ -0,0 +1,465 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpClient = exports.HttpClient = exports.stop = exports.maxSafeTimeout = exports.responseTypes = exports.requestMethods = exports.supportsFormData = exports.supportsResponseStreams = exports.supportsAbortController = exports.supportsRequestStreams = exports.timeout = exports.normalizeRetryOptions = exports.normalizeRequestMethod = exports.deepMerge = exports.mergeHeaders = exports.validateAndMerge = exports.isObject = exports.delay = exports.TimeoutError = exports.HTTPError = exports.composeAbortError = void 0;
+const isDomExceptionSupported = Boolean(globalThis.DOMException);
+// TODO: When targeting Node.js 18, use `signal.throwIfAborted()` (https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/throwIfAborted)
+function composeAbortError(signal) {
+    /*
+    NOTE: Use DomException with AbortError name as specified in MDN docs (https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort)
+    > When abort() is called, the fetch() promise rejects with an Error of type DOMException, with name AbortError.
+    */
+    if (isDomExceptionSupported) {
+        return new DOMException(signal?.reason ?? 'The operation was aborted.', 'AbortError');
+    }
+    // DOMException not supported. Fall back to use of error and override name.
+    const error = new Error(signal?.reason ?? 'The operation was aborted.');
+    error.name = 'AbortError';
+    return error;
+}
+exports.composeAbortError = composeAbortError;
+class HTTPError extends Error {
+    constructor(response, request, options) {
+        const code = (response.status || response.status === 0) ? response.status : '';
+        const title = response.statusText || '';
+        const status = `${code} ${title}`.trim();
+        const reason = status ? `status code ${status}` : 'an unknown error';
+        super(`Request failed with ${reason}`);
+        this.name = 'HTTPError';
+        this.response = response;
+        this.request = request;
+        this.options = options;
+    }
+}
+exports.HTTPError = HTTPError;
+class TimeoutError extends Error {
+    constructor(request) {
+        super('Request timed out');
+        this.name = 'TimeoutError';
+        this.request = request;
+    }
+}
+exports.TimeoutError = TimeoutError;
+async function delay(ms, { signal }) {
+    return new Promise((resolve, reject) => {
+        if (signal) {
+            if (signal.aborted) {
+                reject(composeAbortError(signal));
+                return;
+            }
+            signal.addEventListener('abort', handleAbort, { once: true });
+        }
+        function handleAbort() {
+            reject(composeAbortError(signal));
+            clearTimeout(timeoutId);
+        }
+        const timeoutId = setTimeout(() => {
+            signal?.removeEventListener('abort', handleAbort);
+            resolve();
+        }, ms);
+    });
+}
+exports.delay = delay;
+const isObject = (value) => value !== null && typeof value === 'object';
+exports.isObject = isObject;
+const validateAndMerge = (...sources) => {
+    for (const source of sources) {
+        if ((!(0, exports.isObject)(source) || Array.isArray(source)) && source !== undefined) {
+            throw new TypeError('The `options` argument must be an object');
+        }
+    }
+    return (0, exports.deepMerge)({}, ...sources);
+};
+exports.validateAndMerge = validateAndMerge;
+const mergeHeaders = (source1 = {}, source2 = {}) => {
+    const result = new globalThis.Headers(source1);
+    const isHeadersInstance = source2 instanceof globalThis.Headers;
+    const source = new globalThis.Headers(source2);
+    // @ts-ignore
+    for (const [key, value] of source.entries()) {
+        if ((isHeadersInstance && value === 'undefined') || value === undefined) {
+            result.delete(key);
+        }
+        else {
+            result.set(key, value);
+        }
+    }
+    return result;
+};
+exports.mergeHeaders = mergeHeaders;
+const deepMerge = (...sources) => {
+    let returnValue = {};
+    let headers = {};
+    for (const source of sources) {
+        if (Array.isArray(source)) {
+            if (!Array.isArray(returnValue)) {
+                returnValue = [];
+            }
+            returnValue = [...returnValue, ...source];
+        }
+        else if ((0, exports.isObject)(source)) {
+            for (let [key, value] of Object.entries(source)) {
+                if ((0, exports.isObject)(value) && key in returnValue) {
+                    value = (0, exports.deepMerge)(returnValue[key], value);
+                }
+                returnValue = { ...returnValue, [key]: value };
+            }
+            if ((0, exports.isObject)(source.headers)) {
+                headers = (0, exports.mergeHeaders)(headers, source.headers);
+                returnValue.headers = headers;
+            }
+        }
+    }
+    return returnValue;
+};
+exports.deepMerge = deepMerge;
+const normalizeRequestMethod = (input) => exports.requestMethods.includes(input) ? input.toUpperCase() : input;
+exports.normalizeRequestMethod = normalizeRequestMethod;
+const retryMethods = ['get', 'put', 'head', 'delete', 'options', 'trace'];
+const retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
+const retryAfterStatusCodes = [413, 429, 503];
+const defaultRetryOptions = {
+    limit: 2,
+    methods: retryMethods,
+    statusCodes: retryStatusCodes,
+    afterStatusCodes: retryAfterStatusCodes,
+    maxRetryAfter: Number.POSITIVE_INFINITY,
+    backoffLimit: Number.POSITIVE_INFINITY
+};
+const normalizeRetryOptions = (retry = {}) => {
+    if (typeof retry === 'number') {
+        return {
+            ...defaultRetryOptions,
+            limit: retry
+        };
+    }
+    if (retry.methods && !Array.isArray(retry.methods)) {
+        throw new Error('retry.methods must be an array');
+    }
+    if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
+        throw new Error('retry.statusCodes must be an array');
+    }
+    return {
+        ...defaultRetryOptions,
+        ...retry,
+        afterStatusCodes: retryAfterStatusCodes
+    };
+};
+exports.normalizeRetryOptions = normalizeRetryOptions;
+async function timeout(request, abortController, options) {
+    return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+            if (abortController) {
+                abortController.abort();
+            }
+            reject(new TimeoutError(request));
+        }, options.timeout);
+        options
+            .fetch(request)
+            .then(resolve)
+            .catch(reject)
+            .then(() => {
+            clearTimeout(timeoutId);
+        });
+    });
+}
+exports.timeout = timeout;
+exports.supportsRequestStreams = (() => {
+    let duplexAccessed = false;
+    let hasContentType = false;
+    const supportsReadableStream = typeof globalThis.ReadableStream === 'function';
+    const supportsRequest = typeof globalThis.Request === 'function';
+    if (supportsReadableStream && supportsRequest) {
+        hasContentType = new globalThis.Request('https://empty.invalid', {
+            body: new globalThis.ReadableStream(),
+            method: 'POST',
+            // @ts-expect-error - Types are outdated.
+            get duplex() {
+                duplexAccessed = true;
+                return 'half';
+            }
+        }).headers.has('Content-Type');
+    }
+    return duplexAccessed && !hasContentType;
+})();
+exports.supportsAbortController = typeof globalThis.AbortController === 'function';
+exports.supportsResponseStreams = typeof globalThis.ReadableStream === 'function';
+exports.supportsFormData = typeof globalThis.FormData === 'function';
+exports.requestMethods = ['get', 'post', 'put', 'patch', 'head', 'delete'];
+const validate = () => undefined;
+validate();
+exports.responseTypes = {
+    json: 'application/json',
+    text: 'text/*',
+    formData: 'multipart/form-data',
+    arrayBuffer: '*/*',
+    blob: '*/*'
+};
+// The maximum value of a 32bit int (see issue #117)
+exports.maxSafeTimeout = 2147483647;
+exports.stop = Symbol('stop');
+class HttpClient {
+    static create(input, options) {
+        const client = new HttpClient(input, options);
+        const fn = async () => {
+            if (typeof client._options.timeout === 'number' && client._options.timeout > exports.maxSafeTimeout) {
+                throw new RangeError(`The \`timeout\` option cannot be greater than ${exports.maxSafeTimeout}`);
+            }
+            // Delay the fetch so that body method shortcuts can set the Accept header
+            await Promise.resolve();
+            let response = await client._fetch();
+            for (const hook of client._options.hooks.afterResponse) {
+                const modifiedResponse = await hook(client.request, client._options, client._decorateResponse(response.clone()));
+                if (modifiedResponse instanceof globalThis.Response) {
+                    response = modifiedResponse;
+                }
+            }
+            client._decorateResponse(response);
+            if (!response.ok && client._options.throwHttpErrors) {
+                let error = new HTTPError(response, client.request, client._options);
+                for (const hook of client._options.hooks.beforeError) {
+                    error = await hook(error);
+                }
+                throw error;
+            }
+            if (client._options.onDownloadProgress) {
+                if (typeof client._options.onDownloadProgress !== 'function') {
+                    throw new TypeError('The `onDownloadProgress` option must be a function');
+                }
+                if (!exports.supportsResponseStreams) {
+                    throw new Error('Streams are not supported in your environment. `ReadableStream` is missing.');
+                }
+                return client._stream(response.clone(), client._options.onDownloadProgress);
+            }
+            return response;
+        };
+        // const isRetriableMethod = client._options.retry.methods.includes(client.request.method.toLowerCase())
+        const result = fn(); // (isRetriableMethod ? client._retry(fn) : fn()) as ResponsePromise
+        for (const [type, mimeType] of Object.entries(exports.responseTypes)) {
+            result[type] = async () => {
+                client.request.headers.set('accept', client.request.headers.get('accept') || mimeType);
+                const awaitedResult = await result;
+                const response = awaitedResult.clone();
+                if (type === 'json') {
+                    if (response.status === 204) {
+                        return '';
+                    }
+                    const arrayBuffer = await response.clone().arrayBuffer();
+                    const responseSize = arrayBuffer.byteLength;
+                    if (responseSize === 0) {
+                        return '';
+                    }
+                    if (options.parseJson) {
+                        return options.parseJson(await response.text());
+                    }
+                }
+                return response[type]();
+            };
+        }
+        return result;
+    }
+    // eslint-disable-next-line complexity
+    constructor(input, options = {}) {
+        this._retryCount = 0;
+        this._input = input;
+        this._options = {
+            // TODO: credentials can be removed when the spec change is implemented in all browsers. Context: https://www.chromestatus.com/feature/4539473312350208
+            credentials: this._input.credentials || 'same-origin',
+            ...options,
+            headers: (0, exports.mergeHeaders)(this._input.headers, options.headers),
+            hooks: (0, exports.deepMerge)({
+                beforeRequest: [],
+                beforeRetry: [],
+                beforeError: [],
+                afterResponse: []
+            }, options.hooks),
+            method: (0, exports.normalizeRequestMethod)(options.method ?? this._input.method),
+            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+            prefixUrl: String(options.prefixUrl || ''),
+            retry: (0, exports.normalizeRetryOptions)(options.retry),
+            throwHttpErrors: options.throwHttpErrors !== false,
+            timeout: options.timeout ?? 10000,
+            fetch: options.fetch ?? globalThis.fetch.bind(globalThis)
+        };
+        if (typeof this._input !== 'string' && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
+            throw new TypeError('`input` must be a string, URL, or Request');
+        }
+        if (this._options.prefixUrl && typeof this._input === 'string') {
+            if (this._input.startsWith('/')) {
+                throw new Error('`input` must not begin with a slash when using `prefixUrl`');
+            }
+            if (!this._options.prefixUrl.endsWith('/')) {
+                this._options.prefixUrl += '/';
+            }
+            this._input = this._options.prefixUrl + this._input;
+        }
+        if (exports.supportsAbortController) {
+            this.abortController = new globalThis.AbortController();
+            if (this._options.signal) {
+                const originalSignal = this._options.signal;
+                this._options.signal.addEventListener('abort', () => {
+                    this.abortController.abort(originalSignal.reason);
+                });
+            }
+            this._options.signal = this.abortController.signal;
+        }
+        if (exports.supportsRequestStreams) {
+            // @ts-expect-error - Types are outdated.
+            this._options.duplex = 'half';
+        }
+        this.request = new globalThis.Request(this._input, this._options);
+        if (this._options.searchParams) {
+            const textSearchParams = typeof this._options.searchParams === 'string'
+                ? this._options.searchParams.replace(/^\?/, '')
+                : new URLSearchParams(this._options.searchParams).toString();
+            const searchParams = '?' + textSearchParams;
+            const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
+            // To provide correct form boundary, Content-Type header should be deleted each time when new Request instantiated from another one
+            if (((exports.supportsFormData && this._options.body instanceof globalThis.FormData) ||
+                this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers['content-type'])) {
+                this.request.headers.delete('content-type');
+            }
+            // The spread of `this.request` is required as otherwise it misses the `duplex` option for some reason and throws.
+            this.request = new globalThis.Request(new globalThis.Request(url, { ...this.request }), this._options);
+        }
+        if (this._options.json !== undefined) {
+            this._options.body = JSON.stringify(this._options.json);
+            this.request.headers.set('content-type', this._options.headers.get('content-type') ?? 'application/json');
+            this.request = new globalThis.Request(this.request, { body: this._options.body });
+        }
+    }
+    _calculateRetryDelay(error) {
+        this._retryCount++;
+        if (this._retryCount < this._options.retry.limit && !(error instanceof TimeoutError)) {
+            if (error instanceof HTTPError) {
+                if (!this._options.retry.statusCodes.includes(error.response.status)) {
+                    return 0;
+                }
+                const retryAfter = error.response.headers.get('Retry-After');
+                if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
+                    let after = Number(retryAfter);
+                    if (Number.isNaN(after)) {
+                        after = Date.parse(retryAfter) - Date.now();
+                    }
+                    else {
+                        after *= 1000;
+                    }
+                    if (this._options.retry.maxRetryAfter !== undefined && after > this._options.retry.maxRetryAfter) {
+                        return 0;
+                    }
+                    return after;
+                }
+                if (error.response.status === 413) {
+                    return 0;
+                }
+            }
+            const BACKOFF_FACTOR = 0.3;
+            return Math.min(this._options.retry.backoffLimit, BACKOFF_FACTOR * (2 ** (this._retryCount - 1)) * 1000);
+        }
+        return 0;
+    }
+    _decorateResponse(response) {
+        if (this._options.parseJson) {
+            response.json = async () => this._options.parseJson(await response.text());
+        }
+        return response;
+    }
+    async _retry(fn) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            const ms = Math.min(this._calculateRetryDelay(error), exports.maxSafeTimeout);
+            if (ms !== 0 && this._retryCount > 0) {
+                await delay(ms, { signal: this._options.signal });
+                for (const hook of this._options.hooks.beforeRetry) {
+                    // eslint-disable-next-line no-await-in-loop
+                    const hookResult = await hook({
+                        request: this.request,
+                        options: this._options,
+                        error: error,
+                        retryCount: this._retryCount
+                    });
+                    // If `stop` is returned from the hook, the retry process is stopped
+                    if (hookResult === exports.stop) {
+                        return;
+                    }
+                }
+                return this._retry(fn);
+            }
+            throw error;
+        }
+    }
+    async _fetch() {
+        for (const hook of this._options.hooks.beforeRequest) {
+            // eslint-disable-next-line no-await-in-loop
+            const result = await hook(this.request, this._options);
+            if (result instanceof Request) {
+                this.request = result;
+                break;
+            }
+            if (result instanceof Response) {
+                return result;
+            }
+        }
+        if (this._options.timeout === false) {
+            return this._options.fetch(this.request.clone());
+        }
+        return timeout(this.request.clone(), this.abortController, this._options);
+    }
+    /* istanbul ignore next */
+    _stream(response, onDownloadProgress) {
+        const totalBytes = Number(response.headers.get('content-length')) || 0;
+        let transferredBytes = 0;
+        if (response.status === 204) {
+            if (onDownloadProgress) {
+                onDownloadProgress({ percent: 1, totalBytes, transferredBytes }, new Uint8Array());
+            }
+            return new globalThis.Response(null, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers
+            });
+        }
+        return new globalThis.Response(new globalThis.ReadableStream({
+            async start(controller) {
+                const reader = response.body.getReader();
+                if (onDownloadProgress) {
+                    onDownloadProgress({ percent: 0, transferredBytes: 0, totalBytes }, new Uint8Array());
+                }
+                async function read() {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        controller.close();
+                        return;
+                    }
+                    if (onDownloadProgress) {
+                        transferredBytes += value.byteLength;
+                        const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+                        onDownloadProgress({ percent, transferredBytes, totalBytes }, value);
+                    }
+                    controller.enqueue(value);
+                    await read();
+                }
+                await read();
+            }
+        }), {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+        });
+    }
+}
+exports.HttpClient = HttpClient;
+const createInstance = (defaults) => {
+    const client = (input, options) => HttpClient.create(input, (0, exports.validateAndMerge)(defaults, options));
+    for (const method of exports.requestMethods) {
+        client[method] = (input, options) => {
+            return HttpClient.create(input, (0, exports.validateAndMerge)(defaults, options, { method }));
+        };
+    }
+    client.create = (newDefaults) => createInstance((0, exports.validateAndMerge)(newDefaults));
+    client.extend = (newDefaults) => createInstance((0, exports.validateAndMerge)(defaults, newDefaults));
+    client.stop = exports.stop;
+    return client;
+};
+exports.httpClient = createInstance();
diff --git a/vendor/r4/index.d.ts b/vendor/r4/index.d.ts
index 5dbaa72..a2e8425 100644
--- a/vendor/r4/index.d.ts
+++ b/vendor/r4/index.d.ts
@@ -1,11 +1,16 @@
-import { AxiosBasicCredentials, AxiosInstance, AxiosResponse } from "axios";
-import { TaskDefinitionsMap, TaskDefinitionsNameMap, WorkflowDefinitionsMap, ResourceTypeMap, SearchParams, SubsSubscription } from "./types";
-type PathResourceBody<T extends keyof ResourceTypeMap> = Partial<Omit<ResourceTypeMap[T], "id" | "meta">>;
+import { HttpClientInstance, HTTPError, Input, Options, NormalizedOptions } from './http-client';
+import { TaskDefinitionsMap, WorkflowDefinitionsMap, ResourceTypeMap, SearchParams, SubsSubscription } from './types';
+export { HTTPError };
+export declare function decode(str: string): string;
+export declare function encode(str: string): string;
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare const buildResourceUrl: (resource: string, id?: string) => string;
+type PartialResourceBody<T extends keyof ResourceTypeMap> = Partial<Omit<ResourceTypeMap[T], 'id' | 'meta'>>;
 type SetOptional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
-export type UnnecessaryKeys = "contained" | "extension" | "modifierExtension" | "_id" | "meta" | "implicitRules" | "_implicitRules" | "language" | "_language";
-type Dir = "asc" | "desc";
-export type PrefixWithArray = "eq" | "ne";
-export type Prefix = "eq" | "ne" | "gt" | "lt" | "ge" | "le" | "sa" | "eb" | "ap";
+export type UnnecessaryKeys = 'contained' | 'extension' | 'modifierExtension' | '_id' | 'meta' | 'implicitRules' | '_implicitRules' | 'language' | '_language';
+type Dir = 'asc' | 'desc';
+export type PrefixWithArray = 'eq' | 'ne';
+export type Prefix = 'eq' | 'ne' | 'gt' | 'lt' | 'ge' | 'le' | 'sa' | 'eb' | 'ap';
 export type ExecuteQueryResponseWrapper<T> = {
     data: T;
     query: string[];
@@ -20,14 +25,13 @@ export type CreateQueryParams = {
 export type CreateQueryBody = {
     params?: Record<string, CreateQueryParams>;
     query: string;
-    "count-query": string;
+    'count-query': string;
 };
 type Link = {
     relation: string;
     url: string;
 };
 export type BaseResponseResources<T extends keyof ResourceTypeMap> = {
-    "query-time": number;
     meta: {
         versionId: string;
     };
@@ -35,11 +39,12 @@ export type BaseResponseResources<T extends keyof ResourceTypeMap> = {
     resourceType: string;
     total: number;
     link: Link[];
-    "query-timeout": number;
-    entry: {
+    entry?: {
         resource: ResourceTypeMap[T];
     }[];
-    "query-sql": (string | number)[];
+    'query-timeout': number;
+    'query-time': number;
+    'query-sql': (string | number)[];
 };
 export type BaseResponseResource<T extends keyof ResourceTypeMap> = ResourceTypeMap[T];
 export type ResourceKeys<T extends keyof ResourceTypeMap, I extends ResourceTypeMap[T]> = Omit<I, UnnecessaryKeys>;
@@ -47,79 +52,208 @@ type SortKey<T extends keyof ResourceTypeMap> = keyof SearchParams[T] | `.${stri
 type ElementsParams<T extends keyof ResourceTypeMap, R extends ResourceTypeMap[T]> = Array<keyof ResourceKeys<T, R>>;
 type ChangeFields<T, R> = Omit<T, keyof R> & R;
 type SubscriptionParams = Omit<ChangeFields<SubsSubscription, {
-    channel: Omit<SubsSubscription["channel"], "type">;
-}>, "resourceType"> & {
+    channel: Omit<SubsSubscription['channel'], 'type'>;
+}>, 'resourceType'> & {
     id: string;
 };
-type BundleRequestEntry<T = ResourceTypeMap[keyof ResourceTypeMap]> = {
-    request: {
-        method: string;
-        url: string;
-    };
-    resource?: T;
-};
-type BundleRequestResponse<T = ResourceTypeMap[keyof ResourceTypeMap]> = {
-    type: "transaction-response";
-    resourceType: "Bundle";
-    entry: Array<T>;
-};
 export type LogData = {
     message: Record<string, any>;
     type: string;
     v?: string;
     fx?: string;
 };
-export declare class Client {
-    client: AxiosInstance;
-    constructor(baseURL: string, credentials: AxiosBasicCredentials);
-    getResources<T extends keyof ResourceTypeMap>(resourceName: T): GetResources<T, ResourceTypeMap[T]>;
-    getResource<T extends keyof ResourceTypeMap>(resourceName: T, id: string): Promise<BaseResponseResource<T>>;
-    deleteResource<T extends keyof ResourceTypeMap>(resourceName: T, id: string): Promise<BaseResponseResource<T>>;
-    createQuery(name: string, body: CreateQueryBody): Promise<any>;
-    executeQuery<T>(name: string, params?: Record<string, unknown>): Promise<AxiosResponse<ExecuteQueryResponseWrapper<T>>>;
-    patchResource<T extends keyof ResourceTypeMap>(resourceName: T, id: string, body: PathResourceBody<T>): Promise<BaseResponseResource<T>>;
-    createResource<T extends keyof ResourceTypeMap>(resourceName: T, body: SetOptional<ResourceTypeMap[T], "resourceType">): Promise<BaseResponseResource<T>>;
-    rawSQL(sql: string, params?: unknown[]): Promise<any>;
-    createSubscription({ id, status, trigger, channel, }: SubscriptionParams): Promise<SubsSubscription>;
-    subscriptionEntry({ id, status, trigger, channel, }: SubscriptionParams): SubsSubscription & {
+export interface R<T> {
+    response: {
+        headers: Headers;
+        url: string;
+        status: number;
+        data: T;
+    };
+}
+export declare class E<T> extends Error {
+    response: R<T>['response'];
+    request: Request;
+    options: NormalizedOptions;
+    constructor(data: T, response: Response, request: Request, options: NormalizedOptions);
+}
+declare class Task {
+    private readonly workers;
+    private client;
+    constructor(client: HttpClientInstance);
+    cancel(id: string): Promise<TaskMeta<import("./types/task/SystemSendMessage").SystemSendMessageParams | {
+        duration: {
+            hours: number;
+            minutes: number;
+            seconds: number;
+        };
+        until?: undefined;
+    } | {
+        duration?: undefined;
+        until: string;
+    } | undefined>>;
+    start(id: string, executionId: string): Promise<TasksBatch | undefined>;
+    complete(id: string, executionId: string, payload: unknown): Promise<TasksBatch>;
+    fail(id: string, executionId: string, payload: unknown): Promise<TasksBatch | undefined>;
+    private execute;
+    /**
+     * Return number ready for execution tasks except Decisions task
+     *
+     * @param {string} [definition] - Task definition name
+     * @returns {Promise<number>}
+     *
+     */
+    pendingTasks(definition?: keyof TaskDefinitionsMap): Promise<number>;
+    pendingDecisions(): Promise<number>;
+    history(id: string): Promise<{
+        resource: TaskMeta<TaskInput>;
+        log: Record<string, any>[];
+    }>;
+    inProgress(): Promise<number>;
+    createHandler<T extends TaskInput | DecisionInput>(handler: (task: TaskMeta<T>) => void): (task: TaskMeta<T>) => Promise<void>;
+    poll(params: {
+        workflowDefinitions?: [string];
+        taskDefinitions?: [string];
+    }, options: WorkerOptions): Promise<TaskMeta<import("./types/task/SystemSendMessage").SystemSendMessageParams | {
+        duration: {
+            hours: number;
+            minutes: number;
+            seconds: number;
+        };
+        until?: undefined;
+    } | {
+        duration?: undefined;
+        until: string;
+    } | DecisionInput | undefined>[]>;
+    private runDaemon;
+    implement<K extends keyof Omit<TaskDefinitionsMap, 'awf.task/wait'>>(name: K, handler: TaskHandler<K>, options?: WorkerOptions): void;
+}
+declare class Workflow {
+    private readonly workers;
+    private client;
+    private task;
+    constructor(client: HttpClientInstance, task: Task);
+    private runDaemon;
+    implement<W extends keyof WorkflowDefinitionsMap>(name: W, handler: WorkflowHandler<W>, options?: WorkerOptions): void;
+    private wrapHandler;
+    execute<K extends keyof WorkflowDefinitionsMap>(definition: K, params: WorkflowDefinitionsMap[K]['params']): Promise<TasksBatch>;
+    terminate(id: string): Promise<AidboxWorkflow>;
+    inProgress(): Promise<number>;
+    history(id: string): Promise<{
+        resource: AidboxWorkflow;
+        activities: TaskMeta<import("./types/task/SystemSendMessage").SystemSendMessageParams | {
+            duration: {
+                hours: number;
+                minutes: number;
+                seconds: number;
+            };
+            until?: undefined;
+        } | {
+            duration?: undefined;
+            until: string;
+        } | undefined>;
+    }>;
+}
+export interface TokenStorage {
+    get: () => Promise<string | null> | string | null;
+    set: (token: string | undefined) => Promise<void> | void;
+}
+type BasicAuthorization = {
+    method: 'basic';
+    credentials: {
+        username: string;
+        password: string;
+    };
+};
+type ResourceOwnerAuthorization = {
+    method: 'resource-owner';
+    client: {
         id: string;
-        resourceType: "SubsSubscription";
+        secret: string;
+    };
+    storage: TokenStorage;
+};
+export declare class Client<T extends BasicAuthorization | ResourceOwnerAuthorization> {
+    private client;
+    private config;
+    task: Task;
+    workflow: Workflow;
+    constructor(baseURL: string, config: {
+        auth: T;
+    });
+    get auth(): (T & BasicAuthorization) | (T & {
+        signIn: ({ username, password }: {
+            username: string;
+            password: string;
+        }) => Promise<{
+            access_token: string;
+            token_type: "Bearer";
+            userinfo: {
+                email: string;
+                id: string;
+            };
+        }>;
+        signUp: () => void;
+        signOut: () => void;
+        method: "resource-owner";
+        client: {
+            id: string;
+            secret: string;
+        };
+        storage: TokenStorage;
+    });
+    HTTPClient: () => {
+        get: <T_1>(url: Input, options?: Options | undefined) => Promise<R<T_1>>;
+        post: <T_1>(url: Input, options?: Options | undefined) => Promise<R<T_1>>;
+        patch: <T_1>(url: Input, options?: Options | undefined) => Promise<R<T_1>>;
+        put: <T_1>(url: Input, options?: Options | undefined) => Promise<R<T_1>>;
+        delete: <T_1>(url: Input, options?: Options | undefined) => Promise<R<T_1>>;
+        head: <T_1>(url: Input, options?: Options | undefined) => Promise<R<T_1>>;
+    };
+    resource: {
+        list: <T_1 extends keyof ResourceTypeMap>(resourceName: T_1) => GetResources<T_1, ResourceTypeMap[T_1]>;
+        get: <T_2 extends keyof ResourceTypeMap>(resourceName: T_2, id: string) => Promise<BaseResponseResource<T_2>>;
+        delete: <T_3 extends keyof ResourceTypeMap>(resourceName: T_3, id: string) => Promise<BaseResponseResource<T_3>>;
+        update: <T_4 extends keyof ResourceTypeMap>(resourceName: T_4, id: string, input: Partial<Omit<ResourceTypeMap[T_4], "id" | "meta">>) => Promise<BaseResponseResource<T_4>>;
+        create: <T_5 extends keyof ResourceTypeMap>(resourceName: T_5, input: SetOptional<ResourceTypeMap[T_5] & {
+            resourceType: string;
+        }, "resourceType">) => Promise<BaseResponseResource<T_5>>;
+        override: <T_6 extends keyof ResourceTypeMap>(resourceName: T_6, id: string, input: Partial<Omit<ResourceTypeMap[T_6], "id" | "meta">>) => Promise<BaseResponseResource<T_6>>;
+    };
+    rpc<T = any>(method: string, params: unknown): Promise<T>;
+    aidboxQuery: {
+        create: (name: string, json: CreateQueryBody) => Promise<unknown>;
+        execute: <T_1>(name: string, params?: Record<string, unknown>) => Promise<ExecuteQueryResponseWrapper<T_1>>;
     };
+    subsSubscription: {
+        create: ({ id, status, trigger, channel }: SubscriptionParams) => Promise<SubsSubscription>;
+    };
+    rawSQL<T>(sql: string, params?: string[]): Promise<T>;
     sendLog(data: LogData): Promise<void>;
-    transformToBundle<RT extends keyof ResourceTypeMap, R extends ResourceTypeMap[RT]>(resources: (R & {
-        resourceType: RT;
-        id: string;
-    })[], method: "PUT" | "PATCH"): BundleRequestEntry<R>[];
-    transformToBundle<RT extends keyof ResourceTypeMap, R extends ResourceTypeMap[RT]>(resources: (R & {
-        resourceType: RT;
-        id?: string;
-    })[], method: "POST"): BundleRequestEntry<R>[];
-    bundleRequest(entry: Array<BundleRequestEntry>, type?: "transaction" | "batch"): Promise<BundleRequestResponse>;
 }
 export declare class GetResources<T extends keyof ResourceTypeMap, R extends ResourceTypeMap[T]> implements PromiseLike<BaseResponseResources<T>> {
     private searchParamsObject;
     resourceName: T;
-    client: AxiosInstance;
-    constructor(client: AxiosInstance, resourceName: T);
+    client: HttpClientInstance;
+    constructor(client: HttpClientInstance, resourceName: T);
     where<K extends keyof SearchParams[T], SP extends SearchParams[T][K], PR extends PrefixWithArray>(key: K | string, value: SP | SP[], prefix?: PR): this;
     where<K extends keyof SearchParams[T], SP extends SearchParams[T][K], PR extends Exclude<Prefix, PrefixWithArray>>(key: K | string, value: SP, prefix?: PR): this;
-    contained(contained: boolean | "both", containedType?: "container" | "contained"): this;
+    contained(contained: boolean | 'both', containedType?: 'container' | 'contained'): this;
     count(value: number): this;
     elements(args: ElementsParams<T, R>): this;
-    summary(type: boolean | "text" | "data" | "count"): this;
+    summary(type: boolean | 'text' | 'data' | 'count'): this;
     sort(key: SortKey<T>, dir: Dir): this;
-    then<TResult1 = BaseResponseResources<T>, TResult2 = never>(onfulfilled?: ((value: BaseResponseResources<T>) => PromiseLike<TResult1> | TResult1) | undefined | null, onrejected?: ((reason: any) => PromiseLike<TResult2> | TResult2) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    then<TResult1 = BaseResponseResources<T>, TResult2 = never>(onfulfilled?: ((value: BaseResponseResources<T>) => PromiseLike<TResult1> | TResult1) | undefined | null, _onrejected?: ((reason: unknown) => PromiseLike<TResult2> | TResult2) | undefined | null): PromiseLike<TResult1 | TResult2>;
 }
-type EventType = "awf.workflow.event/workflow-init" | "awf.workflow.event/task-completed";
-type TaskStatus = "requested" | "in-progress";
-type RequesterType = "AidboxWorkflow";
-interface Meta<T> {
+type EventType = 'awf.workflow.event/workflow-init' | 'awf.workflow.event/task-completed';
+type TaskStatus = 'requested' | 'in-progress';
+type RequesterType = 'AidboxWorkflow';
+interface TaskMeta<T> {
     id: string;
     execId: string;
     definition: string;
     params: T;
-    "workflow-definition": string;
-    resourceType: "AidboxTask";
+    'workflow-definition': string;
+    resourceType: 'AidboxTask';
     status: TaskStatus;
     requester: {
         id: string;
@@ -135,60 +269,71 @@ type WorkerOptions = {
     pollInterval?: number;
     batchSize?: number;
 };
-type TaskInput = TaskDefinitionsMap[keyof TaskDefinitionsMap]["params"];
+type TaskInput = TaskDefinitionsMap[keyof TaskDefinitionsMap]['params'];
 type DecisionInput = {
     event: EventType;
 };
 interface TasksBatch {
     result: {
-        resources: Array<Meta<TaskInput | DecisionInput>>;
+        resources: Array<TaskMeta<TaskInput | DecisionInput>>;
+    };
+}
+interface AidboxWorkflow {
+    requester: {
+        id: string;
+        resourceType: string;
+    };
+    retryCount: number;
+    execId: string;
+    status: 'created' | 'in-progress' | 'done';
+    outcome?: 'succeeded' | 'failed' | 'canceled';
+    outcomeReason?: {
+        type: 'awf.task/failed-due-to-in-progress-timeout' | 'awf.workflow/failed-by-executor' | 'awf.executor/unknown-error';
+        message: string;
+        data?: any;
     };
+    result: any;
+    error: any;
 }
 interface WorkflowActions<K extends keyof WorkflowDefinitionsMap> {
-    complete: (params: WorkflowDefinitionsMap[K]["result"]) => {
-        action: "awf.workflow.action/complete-workflow";
-        result: WorkflowDefinitionsMap[K]["result"];
+    complete: (params: WorkflowDefinitionsMap[K]['result']) => {
+        action: 'awf.workflow.action/complete-workflow';
+        result: WorkflowDefinitionsMap[K]['result'];
     };
     execute: <T extends keyof TaskDefinitionsMap>(params: {
         definition: T;
-        params: TaskDefinitionsMap[T]["params"];
+        params: TaskDefinitionsMap[T]['params'];
     }) => {
-        action: "awf.workflow.action/schedule-task";
-        "task-request": {
-            definition: (typeof TaskDefinitionsNameMap)[T];
-            params: TaskDefinitionsMap[T]["params"];
+        action: 'awf.workflow.action/schedule-task';
+        'task-request': {
+            definition: T;
+            params: TaskDefinitionsMap[T]['params'];
         };
     };
-    fail: (params: any) => {
-        action: "awf.workflow.action/fail";
-        error: any;
+    fail: (params: unknown) => {
+        action: 'awf.workflow.action/fail';
+        error: unknown;
     };
 }
-type TaskHandler<K extends keyof TaskDefinitionsMap> = (params: Meta<TaskDefinitionsMap[K]["params"]>) => Promise<TaskDefinitionsMap[K]["result"]> | TaskDefinitionsMap[K]["result"];
-type WorkflowHandler<K extends keyof WorkflowDefinitionsMap> = (params: Meta<DecisionInput>, actions: WorkflowActions<K>) => void;
-export declare class Engine {
-    private readonly client;
-    private readonly workers;
-    constructor(baseURL: string, credentials: AxiosBasicCredentials);
-    task: {
-        execute: <K extends never>(definition: K, params: TaskDefinitionsMap[K]["params"]) => Promise<AxiosResponse<TasksBatch>>;
-        implement: <K_1 extends never>(name: K_1, handler: TaskHandler<K_1>, options?: WorkerOptions) => void;
-    };
-    workflow: {
-        execute: <K extends never>(name: K, params: WorkflowDefinitionsMap[K]["params"]) => Promise<AxiosResponse<TasksBatch>>;
-        implement: <W extends never>(name: W, handler: WorkflowHandler<W>, options?: WorkerOptions) => void;
-    };
-    runDaemon(poll: () => Promise<Array<Meta<TaskInput | DecisionInput>>>, handler: (input: any) => any, options: WorkerOptions): Promise<void>;
-    wrapHandler<W extends keyof WorkflowDefinitionsMap>(handler: WorkflowHandler<W>): (params: Meta<DecisionInput>) => void;
-    createHandler<T extends TaskInput | DecisionInput>(handler: (task: Meta<T>) => void): (task: Meta<T>) => Promise<void>;
-    poll(params: {
-        workflowDefinitions?: [string];
-        taskDefinitions?: [string];
-    }, options: WorkerOptions): Promise<Meta<DecisionInput>[]>;
-    startTask(id: string, executionId: string): Promise<AxiosResponse<TasksBatch, any>> | undefined;
-    completeTask(id: string, executionId: string, payload: unknown): Promise<AxiosResponse<TasksBatch, any>>;
-    failTask(id: string, executionId: string, payload: unknown): Promise<AxiosResponse<TasksBatch, any>> | undefined;
-    executeWorkflow<K extends keyof WorkflowDefinitionsMap>(name: K, params: WorkflowDefinitionsMap[K]["params"]): Promise<AxiosResponse<TasksBatch>>;
-    executeTask<K extends keyof TaskDefinitionsMap>(definition: K, params: TaskDefinitionsMap[K]["params"]): Promise<AxiosResponse<TasksBatch>>;
+type TaskHandler<K extends keyof Omit<TaskDefinitionsMap, 'awf.task/wait'>> = (params: TaskMeta<TaskDefinitionsMap[K]['params']>) => Promise<TaskDefinitionsMap[K]['result']> | TaskDefinitionsMap[K]['result'];
+type WorkflowHandler<K extends keyof WorkflowDefinitionsMap> = (params: TaskMeta<DecisionInput>, actions: WorkflowActions<K>) => void;
+type BundleRequestEntry<T = ResourceTypeMap[keyof ResourceTypeMap]> = {
+    request: {
+        method: string;
+        url: string;
+    };
+    resource?: T;
+};
+export type HTTPMethod = 'POST' | 'PATCH' | 'PUT' | 'GET';
+export declare class Bundle {
+    entry: BundleRequestEntry[];
+    type: 'batch' | 'transaction';
+    constructor(type?: 'batch' | 'transaction');
+    addEntry<T extends keyof ResourceTypeMap>(resource: ResourceTypeMap[T], { method, resourceName, id }: {
+        method: HTTPMethod;
+        resourceName: T;
+        id?: string;
+    }): void;
+    toJSON(): ResourceTypeMap['Bundle'];
+    toString(): string;
 }
-export {};
diff --git a/vendor/r4/index.js b/vendor/r4/index.js
index b5537e6..a55076b 100644
--- a/vendor/r4/index.js
+++ b/vendor/r4/index.js
@@ -1,329 +1,485 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Engine = exports.GetResources = exports.Client = void 0;
-const axios_1 = require("axios");
-const types_1 = require("./types");
-function buildURL(url) {
-    return "/fhir/" + url;
+exports.Bundle = exports.GetResources = exports.Client = exports.E = exports.buildResourceUrl = exports.sleep = exports.encode = exports.decode = exports.HTTPError = void 0;
+const tslib_1 = require("tslib");
+const base64_1 = tslib_1.__importDefault(require("@juanelas/base64"));
+const http_client_1 = require("./http-client");
+Object.defineProperty(exports, "HTTPError", { enumerable: true, get: function () { return http_client_1.HTTPError; } });
+function decode(str) {
+    return base64_1.default.decode(str, true).toString();
 }
-class Client {
-    constructor(baseURL, credentials) {
-        this.client = axios_1.default.create({
-            baseURL: baseURL.endsWith("/")
-                ? baseURL.slice(0, baseURL.length - 1)
-                : baseURL,
-            auth: credentials,
-        });
-    }
-    getResources(resourceName) {
-        return new GetResources(this.client, resourceName);
+exports.decode = decode;
+function encode(str) {
+    return base64_1.default.encode(str);
+}
+exports.encode = encode;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+exports.sleep = sleep;
+const buildResourceUrl = (resource, id) => ['fhir', resource, id && id].filter(Boolean).join('/');
+exports.buildResourceUrl = buildResourceUrl;
+class E extends Error {
+    constructor(data, response, request, options) {
+        const code = (response.status || response.status === 0) ? response.status : '';
+        const title = response.statusText || '';
+        const status = `${code} ${title}`.trim();
+        const reason = status ? `status code ${status}` : 'an unknown error';
+        super(`Request failed with ${reason}`);
+        this.name = 'HTTPError';
+        this.response = { status: response.status, headers: response.headers, url: response.url, data };
+        this.request = request;
+        this.options = options;
     }
-    getResource(resourceName, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.client.get(buildURL(resourceName + "/" + id));
-            return response.data;
-        });
+}
+exports.E = E;
+const request = (fn) => async (url, options) => {
+    try {
+        const response = await fn(url, options);
+        return { response: { url: response.url, headers: response.headers, status: response.status, data: await response.json() } };
+    }
+    catch (error) {
+        if (error instanceof http_client_1.HTTPError) {
+            const data = await error.response.json();
+            throw new E(data, error.response, error.request, error.options);
+        }
+        throw error;
     }
-    deleteResource(resourceName, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.client.delete(buildURL(resourceName + "/" + id));
-            return response.data;
-        });
+};
+class Task {
+    constructor(client) {
+        this.client = client;
+        this.workers = [];
     }
-    createQuery(name, body) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.client.put(`/AidboxQuery/${name}`, body);
-            return response.data;
-        });
+    async cancel(id) {
+        const response = await this.client.post('rpc', {
+            json: {
+                method: 'awf.task/cancel',
+                params: { id }
+            }
+        }).json();
+        return response.result.resource;
     }
-    executeQuery(name, params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const queryParams = new URLSearchParams();
-            if (params) {
-                for (const key of Object.keys(params)) {
-                    const value = params[key];
-                    if (value) {
-                        queryParams.set(key, value.toString());
-                    }
+    async start(id, executionId) {
+        try {
+            return this.client.post('rpc', {
+                json: {
+                    method: 'awf.task/start',
+                    params: { id, execId: executionId }
                 }
+            }).json();
+        }
+        catch (error) {
+            if (error.name === 'HTTPError') {
+                const errorJson = await error.response.json();
+                console.dir(errorJson, { depth: 5 });
             }
-            return this.client.get(`$query/${name}`, {
-                params: queryParams,
-            });
-        });
+        }
     }
-    patchResource(resourceName, id, body) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.client.patch(buildURL(resourceName + "/" + id), Object.assign({}, body));
-            return response.data;
-        });
+    async complete(id, executionId, payload) {
+        return this.client.post('rpc', {
+            json: {
+                method: 'awf.task/success',
+                params: { id, execId: executionId, result: payload }
+            }
+        }).json();
     }
-    createResource(resourceName, 
-    //@ts-ignore
-    body) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.client.post(buildURL(resourceName), Object.assign({}, body));
-            return response.data;
-        });
+    async fail(id, executionId, payload) {
+        try {
+            return this.client.post('rpc', {
+                json: {
+                    method: 'awf.task/fail',
+                    params: { id, execId: executionId, result: payload }
+                }
+            }).json();
+        }
+        catch (error) {
+            if (error.name === 'HTTPError') {
+                const errorJson = await error.response.json();
+                console.dir(errorJson, { depth: 5 });
+            }
+        }
     }
-    rawSQL(sql, params) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const body = [sql, ...((_a = params === null || params === void 0 ? void 0 : params.map((value) => value === null || value === void 0 ? void 0 : value.toString())) !== null && _a !== void 0 ? _a : [])];
-            const response = yield this.client.post("/$sql", body);
-            return response.data;
-        });
+    execute(definition, params) {
+        return this.client.post('rpc', {
+            json: {
+                method: 'awf.task/create-and-execute',
+                params: { definition, params }
+            }
+        }).json();
+    }
+    /**
+     * Return number ready for execution tasks except Decisions task
+     *
+     * @param {string} [definition] - Task definition name
+     * @returns {Promise<number>}
+     *
+     */
+    async pendingTasks(definition) {
+        const params = new URLSearchParams({ '_count': '0', '.status': 'ready', 'definition-not': 'awf.workflow/decision-task' });
+        if (definition) {
+            params.append('definition', definition);
+            params.delete('definition-not');
+        }
+        return this.client.get('AidboxTask', {
+            searchParams: params
+        }).json().then(r => r.total);
+    }
+    async pendingDecisions() {
+        return this.client.get('AidboxTask', {
+            searchParams: new URLSearchParams({ '_count': '0', '.status': 'ready', 'definition': 'awf.workflow/decision-task' })
+        }).json().then(r => r.total);
+    }
+    async history(id) {
+        return this.client.post('rpc', {
+            json: {
+                method: 'awf.task/status',
+                params: { id, 'include-log?': true }
+            }
+        }).json().then(r => r.result);
     }
-    createSubscription({ id, status, trigger, channel, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.client.put(`SubsSubscription/${id}`, {
-                status,
-                trigger,
-                channel: Object.assign(Object.assign({}, channel), { type: "rest-hook" }),
-            });
-            return response.data;
-        });
+    async inProgress() {
+        return this.client.get('AidboxTask', {
+            searchParams: new URLSearchParams({ '_count': '0', '.status': 'in-progress' })
+        }).json().then(r => r.total);
     }
-    subscriptionEntry({ id, status, trigger, channel, }) {
-        return {
-            resourceType: "SubsSubscription",
-            id,
-            status,
-            trigger,
-            channel: Object.assign(Object.assign({}, channel), { type: "rest-hook" }),
+    createHandler(handler) {
+        return async (task) => {
+            await this.start(task.id, task.execId);
+            try {
+                const result = await handler(task);
+                await this.complete(task.id, task.execId, result);
+            }
+            catch (error) {
+                if (error.name === 'HTTPError') {
+                    const errorJson = await error.response.json();
+                    console.dir(errorJson, { depth: 5 });
+                    await this.fail(task.id, task.execId, errorJson);
+                }
+                else {
+                    console.dir(error, { depth: 5 });
+                    // for some reason does not fail the task
+                    await this.fail(task.id, task.execId, error);
+                }
+            }
         };
     }
-    sendLog(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.post("/$loggy", data);
+    async poll(params, options) {
+        const tasksBatch = await this.client.post('rpc', {
+            json: {
+                method: 'awf.task/poll',
+                params: { ...params, maxBatchSize: options.batchSize }
+            }
+        }).json();
+        return tasksBatch.result.resources;
+    }
+    async runDaemon(poll, handler, options) {
+        while (true) {
+            const tasks = await poll();
+            await Promise.allSettled(tasks.map(async (task) => handler(task)));
+            await (0, exports.sleep)(options.pollInterval || 1000);
+        }
+    }
+    implement(name, handler, options = {}) {
+        const worker = this.runDaemon(() => this.poll({ taskDefinitions: [name] }, options), this.createHandler(handler), options);
+        this.workers.push(worker);
+    }
+}
+class Workflow {
+    constructor(client, task) {
+        this.client = client;
+        this.task = task;
+        this.workers = [];
+    }
+    async runDaemon(poll, handler, options) {
+        while (true) {
+            const tasks = await poll();
+            await Promise.allSettled(tasks.map(async (task) => handler(task)));
+            await (0, exports.sleep)(options.pollInterval || 1000);
+        }
+    }
+    implement(name, handler, options = {}) {
+        const worker = this.runDaemon(() => this.task.poll({ workflowDefinitions: [name] }, options), this.task.createHandler(this.wrapHandler(handler)), options);
+        this.workers.push(worker);
+    }
+    wrapHandler(handler) {
+        return (params) => handler(params, {
+            complete: (result) => ({
+                action: 'awf.workflow.action/complete-workflow',
+                result
+            }),
+            execute: (params) => ({
+                'action': 'awf.workflow.action/schedule-task',
+                'task-request': { definition: params.definition, params: params.params }
+            }),
+            fail: (error) => ({ action: 'awf.workflow.action/fail', error })
         });
     }
-    transformToBundle(resources, method) {
-        return resources.map((resource) => ({
-            request: {
-                method,
-                url: method === "POST"
-                    ? `/${resource.resourceType}`
-                    : `/${resource.resourceType}/${resource.id}`,
+    execute(definition, params) {
+        return this.client.post('rpc', {
+            json: {
+                method: 'awf.workflow/create-and-execute',
+                params: { definition, params }
+            }
+        }).json();
+    }
+    async terminate(id) {
+        return this.client.post('rpc', {
+            json: {
+                method: 'awf.workflow/cancel',
+                params: { id }
+            }
+        }).json().then(r => r.result.resource);
+    }
+    async inProgress() {
+        return this.client.get('AidboxWorkflow', {
+            searchParams: new URLSearchParams({ '_count': '0', '.status': 'in-progress' })
+        }).json().then(r => r.total);
+    }
+    async history(id) {
+        return this.client.post('rpc', {
+            json: {
+                method: 'awf.workflow/status',
+                params: { id, 'include-activities?': true }
+            }
+        }).json().then(r => r.result);
+    }
+}
+const resourceOwnerAuthorization = (httpclient, auth) => async ({ username, password }) => {
+    if (typeof auth.storage.set === 'function') {
+        await auth.storage.set('');
+    }
+    const response = await httpclient.post('auth/token', {
+        json: {
+            username,
+            password,
+            client_id: auth.client.id,
+            client_secret: auth.client.secret,
+            grant_type: 'password'
+        }
+    }).json();
+    if (typeof auth.storage.set === 'function') {
+        await auth.storage.set(response.access_token);
+    }
+    return response;
+};
+const resourceOwnerLogout = (httpclient, auth) => async () => {
+    auth.storage.set(undefined);
+};
+function isBasic(params) {
+    return params.method === 'basic';
+}
+function isResourceOwner(params) {
+    return params.method === 'resource-owner';
+}
+class Client {
+    constructor(baseURL, config) {
+        // переделать на reduce и добавить полей
+        this.HTTPClient = () => ({
+            get: request(this.client.get),
+            post: request(this.client.post),
+            patch: request(this.client.patch),
+            put: request(this.client.put),
+            delete: request(this.client.delete),
+            head: request(this.client.head)
+        });
+        this.resource = {
+            list: (resourceName) => {
+                return new GetResources(this.client, resourceName);
             },
-            resource,
-        }));
-    }
-    bundleRequest(entry, type = "transaction") {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.client.post("/", {
-                resourceType: "Bundle",
-                type,
-                entry,
-            });
-            return response.data;
+            get: async (resourceName, id) => {
+                return this.client.get((0, exports.buildResourceUrl)(resourceName, id)).json();
+            },
+            delete: async (resourceName, id) => {
+                return this.client.delete((0, exports.buildResourceUrl)(resourceName, id)).json();
+            },
+            update: async (resourceName, id, input) => {
+                return this.client.patch((0, exports.buildResourceUrl)(resourceName, id), { json: input }).json();
+            },
+            create: async (resourceName, input) => {
+                return this.client.post((0, exports.buildResourceUrl)(resourceName), { json: input }).json();
+            },
+            override: async (resourceName, id, input) => {
+                return this.client.put((0, exports.buildResourceUrl)(resourceName, id), { json: input }).json();
+            }
+        };
+        this.aidboxQuery = {
+            create: async (name, json) => {
+                const response = await this.client.put(`AidboxQuery/${name}`, { json });
+                return response.json();
+            },
+            execute: async (name, params) => {
+                const queryParams = new URLSearchParams();
+                if (params) {
+                    for (const key of Object.keys(params)) {
+                        const value = params[key];
+                        if (value) {
+                            queryParams.set(key, value.toString());
+                        }
+                    }
+                }
+                return this.client.get(`/$query/${name}`, {
+                    searchParams: queryParams
+                }).json();
+            }
+        };
+        this.subsSubscription = {
+            create: async ({ id, status, trigger, channel }) => {
+                const response = await this.client.put(`/SubsSubscription/${id}`, {
+                    json: {
+                        status,
+                        trigger,
+                        channel: { ...channel, type: 'rest-hook' }
+                    }
+                });
+                return response.json();
+            }
+        };
+        this.config = config;
+        const client = http_client_1.httpClient.create({
+            prefixUrl: baseURL,
+            throwHttpErrors: true,
+            hooks: {
+                beforeRequest: [
+                    async (request) => {
+                        if (isBasic(config.auth)) {
+                            const { username, password } = config.auth.credentials;
+                            request.headers.set('Authorization', `Basic ${encode(`${username}:${password}`)}`);
+                        }
+                        if (isResourceOwner(config.auth)) {
+                            const token = config.auth.storage.get();
+                            if (token)
+                                request.headers.set('Authorization', `Bearer ${token}`);
+                        }
+                    }
+                ]
+            }
+        });
+        const taskClient = new Task(client);
+        this.task = taskClient;
+        this.workflow = new Workflow(client, taskClient);
+        this.client = client;
+    }
+    get auth() {
+        if (isBasic(this.config.auth))
+            return this.config.auth;
+        if (isResourceOwner(this.config.auth)) {
+            return {
+                ...this.config.auth,
+                signIn: resourceOwnerAuthorization(this.client, this.config.auth),
+                signUp: () => { console.log('TBD'); },
+                signOut: () => { console.log('TBD'); }
+            };
+        }
+        throw new Error('');
+    }
+    async rpc(method, params) {
+        const response = await this.client.post('rpc', {
+            method: 'POST',
+            json: { method, params }
         });
+        return response.json();
+    }
+    async rawSQL(sql, params) {
+        const body = [sql, ...(params?.map((value) => value?.toString()) ?? [])];
+        const response = await this.client.post('$sql', { json: body });
+        return response.json();
+    }
+    async sendLog(data) {
+        await this.client.post('$loggy', { json: data });
     }
 }
 exports.Client = Client;
 class GetResources {
     constructor(client, resourceName) {
-        this.client = client;
         this.searchParamsObject = new URLSearchParams();
         this.resourceName = resourceName;
+        this.client = client;
     }
     where(key, value, prefix) {
         if (Array.isArray(value)) {
             const val = value;
             if (prefix) {
-                if (prefix === "eq") {
-                    this.searchParamsObject.append(key.toString(), val.join(","));
+                if (prefix === 'eq') {
+                    this.searchParamsObject.append(key.toString(), val.join(','));
                     return this;
                 }
-                val.map((item) => {
+                val.forEach((item) => {
                     this.searchParamsObject.append(key.toString(), `${prefix}${item}`);
                 });
                 return this;
             }
-            const queryValues = val.join(",");
+            const queryValues = val.join(',');
             this.searchParamsObject.append(key.toString(), queryValues);
             return this;
         }
-        const queryValue = `${prefix !== null && prefix !== void 0 ? prefix : ""}${value}`;
+        const queryValue = `${prefix ?? ''}${value}`;
         this.searchParamsObject.append(key.toString(), queryValue);
         return this;
     }
     contained(contained, containedType) {
-        this.searchParamsObject.set("_contained", contained.toString());
+        this.searchParamsObject.set('_contained', contained.toString());
         if (containedType) {
-            this.searchParamsObject.set("_containedType", containedType);
+            this.searchParamsObject.set('_containedType', containedType);
         }
         return this;
     }
     count(value) {
-        this.searchParamsObject.set("_count", value.toString());
+        this.searchParamsObject.set('_count', value.toString());
         return this;
     }
     elements(args) {
-        const queryValue = args.join(",");
-        this.searchParamsObject.set("_elements", queryValue);
+        const queryValue = args.join(',');
+        this.searchParamsObject.set('_elements', queryValue);
         return this;
     }
     summary(type) {
-        this.searchParamsObject.set("_summary", type.toString());
+        this.searchParamsObject.set('_summary', type.toString());
         return this;
     }
     sort(key, dir) {
-        const existedSortParams = this.searchParamsObject.get("_sort");
+        const existedSortParams = this.searchParamsObject.get('_sort');
         if (existedSortParams) {
-            const newSortParams = `${existedSortParams},${dir === "asc" ? "-" : ""}${key.toString()}`;
-            this.searchParamsObject.set("_sort", newSortParams);
+            const newSortParams = `${existedSortParams},${dir === 'asc' ? '-' : ''}${key.toString()}`;
+            this.searchParamsObject.set('_sort', newSortParams);
             return this;
         }
-        this.searchParamsObject.set("_sort", dir === "asc" ? `-${key.toString()}` : key.toString());
+        this.searchParamsObject.set('_sort', dir === 'asc' ? `-${key.toString()}` : key.toString());
         return this;
     }
-    then(onfulfilled, onrejected) {
-        return this.client
-            .get(buildURL(this.resourceName), {
-            params: this.searchParamsObject,
-        })
+    then(onfulfilled, _onrejected) {
+        return this.client.get((0, exports.buildResourceUrl)(this.resourceName), { searchParams: this.searchParamsObject })
             .then((response) => {
-            return onfulfilled
-                ? onfulfilled(response.data)
-                : response.data;
+            return onfulfilled ? onfulfilled(response.json()) : response.json();
         });
     }
 }
 exports.GetResources = GetResources;
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-class Engine {
-    constructor(baseURL, credentials) {
-        this.task = {
-            execute: this.executeTask.bind(this),
-            implement: (name, handler, options = {}) => {
-                const worker = this.runDaemon(() => this.poll({ taskDefinitions: [types_1.TaskDefinitionsNameMap[name]] }, options), this.createHandler(handler), options);
-                this.workers.push(worker);
-            },
-        };
-        this.workflow = {
-            execute: this.executeWorkflow.bind(this),
-            implement: (name, handler, options = {}) => {
-                const worker = this.runDaemon(() => this.poll({ workflowDefinitions: [types_1.WorkflowDefinitionsNameMap[name]] }, options), this.createHandler(this.wrapHandler(handler)), options);
-                this.workers.push(worker);
-            },
-        };
-        this.client = axios_1.default.create({
-            baseURL: baseURL.endsWith("/")
-                ? baseURL.slice(0, baseURL.length - 1)
-                : baseURL,
-            auth: credentials,
-        });
-        this.workers = [];
+class Bundle {
+    constructor(type = 'transaction') {
+        this.type = type;
+        this.entry = [];
     }
-    runDaemon(poll, handler, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (true) {
-                const tasks = yield poll();
-                yield Promise.allSettled(tasks.map((task) => __awaiter(this, void 0, void 0, function* () { return handler(task); })));
-                yield sleep(options.pollInterval || 1000);
-            }
-        });
-    }
-    wrapHandler(handler) {
-        return (params) => handler(params, {
-            complete: (result) => ({
-                action: "awf.workflow.action/complete-workflow",
-                result,
-            }),
-            execute: (params) => ({
-                action: "awf.workflow.action/schedule-task",
-                "task-request": {
-                    definition: types_1.TaskDefinitionsNameMap[params.definition],
-                    params: params.params,
-                },
-            }),
-            fail: (error) => ({ action: "awf.workflow.action/fail", error }),
-        });
-    }
-    createHandler(handler) {
-        return (task) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            yield this.startTask(task.id, task.execId);
-            try {
-                const result = yield handler(task);
-                yield this.completeTask(task.id, task.execId, result);
-            }
-            catch (error) {
-                console.error((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data);
-                yield this.failTask(task.id, task.execId, error);
-            }
-        });
-    }
-    poll(params, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { data: tasksBatch } = yield this.client.post("/rpc", {
-                method: "awf.task/poll",
-                params: Object.assign(Object.assign({}, params), { maxBatchSize: options.batchSize }),
-            });
-            return tasksBatch.result.resources;
+    addEntry(resource, { method, resourceName, id }) {
+        this.entry.push({
+            request: {
+                method,
+                url: (0, exports.buildResourceUrl)(resourceName, id)
+            },
+            resource: { ...resource, resourceType: resourceName }
         });
     }
-    startTask(id, executionId) {
-        var _a;
-        try {
-            return this.client.post("/rpc", {
-                method: "awf.task/start",
-                params: { id, execId: executionId },
-            });
-        }
-        catch (error) {
-            console.error((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data);
-        }
+    toJSON() {
+        return {
+            resourceType: 'Bundle',
+            type: this.type,
+            entry: this.entry
+        };
     }
-    completeTask(id, executionId, payload) {
-        return this.client.post("/rpc", {
-            method: "awf.task/success",
-            params: { id, execId: executionId, result: payload },
+    toString() {
+        return JSON.stringify({
+            resourceType: 'Bundle',
+            type: this.type,
+            entry: this.entry
         });
     }
-    failTask(id, executionId, payload) {
-        var _a;
-        try {
-            return this.client.post("/rpc", {
-                method: "awf.task/fail",
-                params: { id, execId: executionId, result: payload },
-            });
-        }
-        catch (error) {
-            console.error((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data);
-        }
-    }
-    executeWorkflow(name, params) {
-        try {
-            return this.client.post("/rpc", {
-                method: "awf.workflow/create-and-execute",
-                params: { definition: types_1.WorkflowDefinitionsNameMap[name], params },
-            });
-        }
-        catch (error) {
-            throw error === null || error === void 0 ? void 0 : error.response;
-        }
-    }
-    executeTask(definition, params) {
-        try {
-            return this.client.post("/rpc", {
-                method: "awf.task/create-and-execute",
-                params: { definition: types_1.TaskDefinitionsNameMap[definition], params },
-            });
-        }
-        catch (error) {
-            throw error === null || error === void 0 ? void 0 : error.response;
-        }
-    }
 }
-exports.Engine = Engine;
+exports.Bundle = Bundle;
diff --git a/vendor/r4/package.json b/vendor/r4/package.json
index 8506c0f..ee7e31e 100644
--- a/vendor/r4/package.json
+++ b/vendor/r4/package.json
@@ -1,26 +1,37 @@
 {
-    "name": "@aidbox/sdk-r4",
-    "version": "1.0.3",
-    "description": "Default Aidbox SDK with HL7-R4 package",
-    "main": "index.js",
-    "scripts": {
-        "build": "tsc",
-        "format": "prettier --write \"src/**/*.ts\""
-    },
-    "keywords": [],
-    "author": "",
-    "license": "ISC",
-    "dependencies": {
-        "axios": "1.3.3"
-    },
-    "devDependencies": {
-        "typescript": "4.9.5",
-        "prettier": "^2.8.4"
-    },
-    "files": [
-        "types",
-        "index.js",
-        "index.d.ts",
-        "package.json"
-    ]
-}
\ No newline at end of file
+  "name": "@aidbox/sdk-r4",
+  "version": "1.0.8",
+  "description": "Default Aidbox SDK with HL7-R4 package",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\""
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "types": "index.d.ts",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@juanelas/base64": "^1.1.2",
+    "tslib": "^2.6.1"
+  },
+  "devDependencies": {
+    "@type-challenges/utils": "^0.1.1",
+    "@types/node": "^20.4.4",
+    "prettier": "^2.8.4",
+    "ts-node": "10.9.1",
+    "typescript": "4.9.5",
+    "type-fest": "^4.3.1"
+  },
+  "files": [
+    "types",
+    "index.js",
+    "index.d.ts",
+    "http-client.js",
+    "http-client.d.ts",
+    "package.json"
+  ]
+}
diff --git a/vendor/r4/pnpm-lock.yaml b/vendor/r4/pnpm-lock.yaml
new file mode 100644
index 0000000..575e225
--- /dev/null
+++ b/vendor/r4/pnpm-lock.yaml
@@ -0,0 +1,171 @@
+lockfileVersion: 5.4
+
+specifiers:
+  '@juanelas/base64': ^1.1.2
+  '@type-challenges/utils': ^0.1.1
+  '@types/node': ^20.4.4
+  prettier: ^2.8.4
+  ts-node: 10.9.1
+  tslib: ^2.6.1
+  type-fest: ^4.3.1
+  typescript: 4.9.5
+
+dependencies:
+  '@juanelas/base64': 1.1.5
+  tslib: 2.6.2
+
+devDependencies:
+  '@type-challenges/utils': 0.1.1
+  '@types/node': 20.11.16
+  prettier: 2.8.8
+  ts-node: 10.9.1_4lhcgfu2tqlb5z5dwdvf5srjjq
+  type-fest: 4.10.2
+  typescript: 4.9.5
+
+packages:
+
+  /@cspotcode/source-map-support/0.8.1:
+    resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
+    engines: {node: '>=12'}
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.9
+    dev: true
+
+  /@jridgewell/resolve-uri/3.1.1:
+    resolution: {integrity: sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==}
+    engines: {node: '>=6.0.0'}
+    dev: true
+
+  /@jridgewell/sourcemap-codec/1.4.15:
+    resolution: {integrity: sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==}
+    dev: true
+
+  /@jridgewell/trace-mapping/0.3.9:
+    resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.1
+      '@jridgewell/sourcemap-codec': 1.4.15
+    dev: true
+
+  /@juanelas/base64/1.1.5:
+    resolution: {integrity: sha512-mjAF27LzwfYobdwqnxZgeucbKT5wRRNvILg3h5OvCWK+3F7mw/A1tnjHnNiTYtLmTvT/bM1jA5AX7eQawDGs1w==}
+    dev: false
+
+  /@tsconfig/node10/1.0.9:
+    resolution: {integrity: sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==}
+    dev: true
+
+  /@tsconfig/node12/1.0.11:
+    resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==}
+    dev: true
+
+  /@tsconfig/node14/1.0.3:
+    resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==}
+    dev: true
+
+  /@tsconfig/node16/1.0.4:
+    resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==}
+    dev: true
+
+  /@type-challenges/utils/0.1.1:
+    resolution: {integrity: sha512-A7ljYfBM+FLw+NDyuYvGBJiCEV9c0lPWEAdzfOAkb3JFqfLl0Iv/WhWMMARHiRKlmmiD1g8gz/507yVvHdQUYA==}
+    dev: true
+
+  /@types/node/20.11.16:
+    resolution: {integrity: sha512-gKb0enTmRCzXSSUJDq6/sPcqrfCv2mkkG6Jt/clpn5eiCbKTY+SgZUxo+p8ZKMof5dCp9vHQUAB7wOUTod22wQ==}
+    dependencies:
+      undici-types: 5.26.5
+    dev: true
+
+  /acorn-walk/8.3.2:
+    resolution: {integrity: sha512-cjkyv4OtNCIeqhHrfS81QWXoCBPExR/J62oyEqepVw8WaQeSqpW2uhuLPh1m9eWhDuOo/jUXVTlifvesOWp/4A==}
+    engines: {node: '>=0.4.0'}
+    dev: true
+
+  /acorn/8.11.3:
+    resolution: {integrity: sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+    dev: true
+
+  /arg/4.1.3:
+    resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==}
+    dev: true
+
+  /create-require/1.1.1:
+    resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==}
+    dev: true
+
+  /diff/4.0.2:
+    resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
+    engines: {node: '>=0.3.1'}
+    dev: true
+
+  /make-error/1.3.6:
+    resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==}
+    dev: true
+
+  /prettier/2.8.8:
+    resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
+    engines: {node: '>=10.13.0'}
+    hasBin: true
+    dev: true
+
+  /ts-node/10.9.1_4lhcgfu2tqlb5z5dwdvf5srjjq:
+    resolution: {integrity: sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==}
+    hasBin: true
+    peerDependencies:
+      '@swc/core': '>=1.2.50'
+      '@swc/wasm': '>=1.2.50'
+      '@types/node': '*'
+      typescript: '>=2.7'
+    peerDependenciesMeta:
+      '@swc/core':
+        optional: true
+      '@swc/wasm':
+        optional: true
+    dependencies:
+      '@cspotcode/source-map-support': 0.8.1
+      '@tsconfig/node10': 1.0.9
+      '@tsconfig/node12': 1.0.11
+      '@tsconfig/node14': 1.0.3
+      '@tsconfig/node16': 1.0.4
+      '@types/node': 20.11.16
+      acorn: 8.11.3
+      acorn-walk: 8.3.2
+      arg: 4.1.3
+      create-require: 1.1.1
+      diff: 4.0.2
+      make-error: 1.3.6
+      typescript: 4.9.5
+      v8-compile-cache-lib: 3.0.1
+      yn: 3.1.1
+    dev: true
+
+  /tslib/2.6.2:
+    resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==}
+    dev: false
+
+  /type-fest/4.10.2:
+    resolution: {integrity: sha512-anpAG63wSpdEbLwOqH8L84urkL6PiVIov3EMmgIhhThevh9aiMQov+6Btx0wldNcvm4wV+e2/Rt1QdDwKHFbHw==}
+    engines: {node: '>=16'}
+    dev: true
+
+  /typescript/4.9.5:
+    resolution: {integrity: sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==}
+    engines: {node: '>=4.2.0'}
+    hasBin: true
+    dev: true
+
+  /undici-types/5.26.5:
+    resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==}
+    dev: true
+
+  /v8-compile-cache-lib/3.0.1:
+    resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==}
+    dev: true
+
+  /yn/3.1.1:
+    resolution: {integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==}
+    engines: {node: '>=6'}
+    dev: true
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Account.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Account.d.ts
index 784808a..4a523e8 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Account.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Account.d.ts
@@ -6,11 +6,11 @@ import { CodeableConcept } from "./CodeableConcept";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A financial tool for tracking value accrued for a particular purpose.  In the healthcare field, used to track charges for a patient, cost centers, etc. */
 export interface Account extends DomainResource {
+    resourceType: 'Account';
     /** Explanation of purpose/use */
     description?: string;
     /** Human-readable label */
@@ -26,21 +26,21 @@ export interface Account extends DomainResource {
     /** The parties ultimately responsible for balancing the Account */
     guarantor?: Array<AccountGuarantor>;
     /** active | inactive | entered-in-error | on-hold | unknown */
-    status: code;
+    status: `${AccountStatus}`;
     _name?: Element;
     /** Account number */
     identifier?: Array<Identifier>;
     /** Reference to a parent Account */
-    partOf?: Reference<"Account">;
+    partOf?: Reference<'Account'>;
     /** The entity that caused the expenses */
     subject?: Array<Reference>;
     /** Entity managing the Account */
-    owner?: Reference<"Organization">;
+    owner?: Reference<'Organization'>;
 }
 /** The party(s) that are responsible for covering the payment of this account, and what order should they be applied to the account */
 export interface AccountCoverage extends BackboneElement {
     /** The party(s), such as insurances, that may contribute to the payment of this account */
-    coverage: Reference<"Coverage">;
+    coverage: Reference<'Coverage'>;
     /** The priority of the coverage in the context of this account */
     priority?: positiveInt;
     _priority?: Element;
@@ -48,10 +48,18 @@ export interface AccountCoverage extends BackboneElement {
 /** The parties ultimately responsible for balancing the Account */
 export interface AccountGuarantor extends BackboneElement {
     /** Responsible entity */
-    party: Reference<"Patient" | "Organization" | "RelatedPerson">;
+    party: Reference<'Patient' | 'Organization' | 'RelatedPerson'>;
     /** Credit or other hold applied */
     onHold?: boolean;
     _onHold?: Element;
     /** Guarantee account during */
     period?: Period;
 }
+/** active | inactive | entered-in-error | on-hold | unknown */
+export declare enum AccountStatus {
+    Active = "active",
+    EnteredInError = "entered-in-error",
+    Inactive = "inactive",
+    OnHold = "on-hold",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Account.js b/vendor/r4/types/hl7-fhir-r4-core/Account.js
index c8ad2e5..a2e9a0b 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Account.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Account.js
@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountStatus = void 0;
+/** active | inactive | entered-in-error | on-hold | unknown */
+var AccountStatus;
+(function (AccountStatus) {
+    AccountStatus["Active"] = "active";
+    AccountStatus["EnteredInError"] = "entered-in-error";
+    AccountStatus["Inactive"] = "inactive";
+    AccountStatus["OnHold"] = "on-hold";
+    AccountStatus["Unknown"] = "unknown";
+})(AccountStatus = exports.AccountStatus || (exports.AccountStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ActivityDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ActivityDefinition.d.ts
index 9ca158d..581b790 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ActivityDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ActivityDefinition.d.ts
@@ -20,11 +20,11 @@ import { date } from "./date";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context. */
 export interface ActivityDefinition extends DomainResource {
+    resourceType: 'ActivityDefinition';
     /** What observations must be produced by this action */
     observationResultRequirement?: Array<Reference>;
     timingRange?: Range;
@@ -57,7 +57,7 @@ export interface ActivityDefinition extends DomainResource {
     productCodeableConcept?: CodeableConcept;
     /** Name for this activity definition (computer friendly) */
     name?: string;
-    productReference?: Reference<"Medication" | "Substance">;
+    productReference?: Reference<'Medication' | 'Substance'>;
     timingPeriod?: Period;
     _priority?: Element;
     _status?: Element;
@@ -90,14 +90,14 @@ export interface ActivityDefinition extends DomainResource {
     timingDuration?: Duration;
     _lastReviewDate?: Element;
     /** routine | urgent | asap | stat */
-    priority?: code;
+    priority?: `${ActivityDefinitionPriority}`;
     _transform?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${ActivityDefinitionStatus}`;
     /** Subordinate title of the activity definition */
     subtitle?: string;
     /** Kind of resource */
-    kind?: code;
+    kind?: `${ActivityDefinitionKind}`;
     _name?: Element;
     /** Dynamic aspects of the definition */
     dynamicValue?: Array<ActivityDefinitionDynamicValue>;
@@ -118,7 +118,7 @@ export interface ActivityDefinition extends DomainResource {
     bodySite?: Array<CodeableConcept>;
     timingAge?: Age;
     /** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
-    intent?: code;
+    intent?: `${ActivityDefinitionIntent}`;
     _library?: Array<Element>;
     _copyright?: Element;
     _timingDateTime?: Element;
@@ -135,24 +135,63 @@ export interface ActivityDefinition extends DomainResource {
     /** Additional documentation, citations, etc. */
     relatedArtifact?: Array<RelatedArtifact>;
     /** Where it should happen */
-    location?: Reference<"Location">;
+    location?: Reference<'Location'>;
     /** Contact details for the publisher */
     contact?: Array<ContactDetail>;
-    subjectReference?: Reference<"Group">;
+    subjectReference?: Reference<'Group'>;
     _url?: Element;
     /** What profile the resource needs to conform to */
     profile?: canonical;
     /** When the activity definition is expected to be used */
     effectivePeriod?: Period;
 }
+/** patient | practitioner | related-person | device */
+export declare enum ActivityDefinitionType {
+    Device = "device",
+    Patient = "patient",
+    Practitioner = "practitioner",
+    RelatedPerson = "related-person"
+}
 /** Who should participate in the action */
 export interface ActivityDefinitionParticipant extends BackboneElement {
     /** patient | practitioner | related-person | device */
-    type: code;
+    type: `${ActivityDefinitionType}`;
     _type?: Element;
     /** E.g. Nurse, Surgeon, Parent, etc. */
     role?: CodeableConcept;
 }
+/** routine | urgent | asap | stat */
+export declare enum ActivityDefinitionPriority {
+    Asap = "asap",
+    Routine = "routine",
+    Stat = "stat",
+    Urgent = "urgent"
+}
+/** draft | active | retired | unknown */
+export declare enum ActivityDefinitionStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** Kind of resource */
+export declare enum ActivityDefinitionKind {
+    Appointment = "Appointment",
+    NutritionOrder = "NutritionOrder",
+    Contract = "Contract",
+    Claim = "Claim",
+    AppointmentResponse = "AppointmentResponse",
+    VisionPrescription = "VisionPrescription",
+    MedicationRequest = "MedicationRequest",
+    ImmunizationRecommendation = "ImmunizationRecommendation",
+    DeviceRequest = "DeviceRequest",
+    ServiceRequest = "ServiceRequest",
+    SupplyRequest = "SupplyRequest",
+    Task = "Task",
+    CommunicationRequest = "CommunicationRequest",
+    EnrollmentRequest = "EnrollmentRequest",
+    CarePlan = "CarePlan"
+}
 /** Dynamic aspects of the definition */
 export interface ActivityDefinitionDynamicValue extends BackboneElement {
     /** The path to the element to be set dynamically */
@@ -161,3 +200,15 @@ export interface ActivityDefinitionDynamicValue extends BackboneElement {
     /** An expression that provides the dynamic value for the customization */
     expression: Expression;
 }
+/** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
+export declare enum ActivityDefinitionIntent {
+    Order = "order",
+    FillerOrder = "filler-order",
+    Option = "option",
+    Directive = "directive",
+    Proposal = "proposal",
+    ReflexOrder = "reflex-order",
+    Plan = "plan",
+    InstanceOrder = "instance-order",
+    OriginalOrder = "original-order"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ActivityDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/ActivityDefinition.js
index c8ad2e5..21c5235 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ActivityDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ActivityDefinition.js
@@ -1,2 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDefinitionIntent = exports.ActivityDefinitionKind = exports.ActivityDefinitionStatus = exports.ActivityDefinitionPriority = exports.ActivityDefinitionType = void 0;
+/** patient | practitioner | related-person | device */
+var ActivityDefinitionType;
+(function (ActivityDefinitionType) {
+    ActivityDefinitionType["Device"] = "device";
+    ActivityDefinitionType["Patient"] = "patient";
+    ActivityDefinitionType["Practitioner"] = "practitioner";
+    ActivityDefinitionType["RelatedPerson"] = "related-person";
+})(ActivityDefinitionType = exports.ActivityDefinitionType || (exports.ActivityDefinitionType = {}));
+/** routine | urgent | asap | stat */
+var ActivityDefinitionPriority;
+(function (ActivityDefinitionPriority) {
+    ActivityDefinitionPriority["Asap"] = "asap";
+    ActivityDefinitionPriority["Routine"] = "routine";
+    ActivityDefinitionPriority["Stat"] = "stat";
+    ActivityDefinitionPriority["Urgent"] = "urgent";
+})(ActivityDefinitionPriority = exports.ActivityDefinitionPriority || (exports.ActivityDefinitionPriority = {}));
+/** draft | active | retired | unknown */
+var ActivityDefinitionStatus;
+(function (ActivityDefinitionStatus) {
+    ActivityDefinitionStatus["Active"] = "active";
+    ActivityDefinitionStatus["Draft"] = "draft";
+    ActivityDefinitionStatus["Retired"] = "retired";
+    ActivityDefinitionStatus["Unknown"] = "unknown";
+})(ActivityDefinitionStatus = exports.ActivityDefinitionStatus || (exports.ActivityDefinitionStatus = {}));
+/** Kind of resource */
+var ActivityDefinitionKind;
+(function (ActivityDefinitionKind) {
+    ActivityDefinitionKind["Appointment"] = "Appointment";
+    ActivityDefinitionKind["NutritionOrder"] = "NutritionOrder";
+    ActivityDefinitionKind["Contract"] = "Contract";
+    ActivityDefinitionKind["Claim"] = "Claim";
+    ActivityDefinitionKind["AppointmentResponse"] = "AppointmentResponse";
+    ActivityDefinitionKind["VisionPrescription"] = "VisionPrescription";
+    ActivityDefinitionKind["MedicationRequest"] = "MedicationRequest";
+    ActivityDefinitionKind["ImmunizationRecommendation"] = "ImmunizationRecommendation";
+    ActivityDefinitionKind["DeviceRequest"] = "DeviceRequest";
+    ActivityDefinitionKind["ServiceRequest"] = "ServiceRequest";
+    ActivityDefinitionKind["SupplyRequest"] = "SupplyRequest";
+    ActivityDefinitionKind["Task"] = "Task";
+    ActivityDefinitionKind["CommunicationRequest"] = "CommunicationRequest";
+    ActivityDefinitionKind["EnrollmentRequest"] = "EnrollmentRequest";
+    ActivityDefinitionKind["CarePlan"] = "CarePlan";
+})(ActivityDefinitionKind = exports.ActivityDefinitionKind || (exports.ActivityDefinitionKind = {}));
+/** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
+var ActivityDefinitionIntent;
+(function (ActivityDefinitionIntent) {
+    ActivityDefinitionIntent["Order"] = "order";
+    ActivityDefinitionIntent["FillerOrder"] = "filler-order";
+    ActivityDefinitionIntent["Option"] = "option";
+    ActivityDefinitionIntent["Directive"] = "directive";
+    ActivityDefinitionIntent["Proposal"] = "proposal";
+    ActivityDefinitionIntent["ReflexOrder"] = "reflex-order";
+    ActivityDefinitionIntent["Plan"] = "plan";
+    ActivityDefinitionIntent["InstanceOrder"] = "instance-order";
+    ActivityDefinitionIntent["OriginalOrder"] = "original-order";
+})(ActivityDefinitionIntent = exports.ActivityDefinitionIntent || (exports.ActivityDefinitionIntent = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Address.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Address.d.ts
index e327384..d959643 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Address.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Address.d.ts
@@ -2,17 +2,16 @@
 DON'T MODIFY MANUALLY */
 import { Period } from "./Period";
 import { Element } from "./Element";
-import { code } from "./code";
 /** Base StructureDefinition for Address Type: An address expressed using postal conventions (as opposed to GPS or other location definition formats).  This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery.  There are a variety of postal address formats defined around the world. */
 export interface Address extends Element {
     _line?: Array<Element>;
     /** home | work | temp | old | billing - purpose of this address */
-    use?: code;
+    use?: `${AddressUse}`;
     /** Name of city, town etc. */
     city?: string;
     _type?: Element;
     /** postal | physical | both */
-    type?: code;
+    type?: `${AddressType}`;
     _city?: Element;
     /** Sub-unit of country (abbreviations ok) */
     state?: string;
@@ -35,3 +34,17 @@ export interface Address extends Element {
     /** Text representation of the address */
     text?: string;
 }
+/** home | work | temp | old | billing - purpose of this address */
+export declare enum AddressUse {
+    Billing = "billing",
+    Home = "home",
+    Old = "old",
+    Temp = "temp",
+    Work = "work"
+}
+/** postal | physical | both */
+export declare enum AddressType {
+    Both = "both",
+    Physical = "physical",
+    Postal = "postal"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Address.js b/vendor/r4/types/hl7-fhir-r4-core/Address.js
index c8ad2e5..b8147a6 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Address.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Address.js
@@ -1,2 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressType = exports.AddressUse = void 0;
+/** home | work | temp | old | billing - purpose of this address */
+var AddressUse;
+(function (AddressUse) {
+    AddressUse["Billing"] = "billing";
+    AddressUse["Home"] = "home";
+    AddressUse["Old"] = "old";
+    AddressUse["Temp"] = "temp";
+    AddressUse["Work"] = "work";
+})(AddressUse = exports.AddressUse || (exports.AddressUse = {}));
+/** postal | physical | both */
+var AddressType;
+(function (AddressType) {
+    AddressType["Both"] = "both";
+    AddressType["Physical"] = "physical";
+    AddressType["Postal"] = "postal";
+})(AddressType = exports.AddressType || (exports.AddressType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/AdverseEvent.d.ts b/vendor/r4/types/hl7-fhir-r4-core/AdverseEvent.d.ts
index 0988154..24a79a4 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/AdverseEvent.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/AdverseEvent.d.ts
@@ -5,28 +5,28 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Actual or  potential/avoided event causing unintended physical injury resulting from or contributed to by medical care, a research study or other healthcare setting factors that requires additional monitoring, treatment, or hospitalization, or that results in death. */
 export interface AdverseEvent extends DomainResource {
+    resourceType: 'AdverseEvent';
     /** product-problem | product-quality | product-use-error | wrong-dose | incorrect-prescribing-information | wrong-technique | wrong-route-of-administration | wrong-rate | wrong-duration | wrong-time | expired-drug | medical-device-use-error | problem-different-manufacturer | unsafe-physical-environment */
     category?: Array<CodeableConcept>;
     /** actual | potential */
-    actuality: code;
+    actuality: `${AdverseEventActuality}`;
     /** When the event occurred */
     date?: dateTime;
     /** AdverseEvent.study */
     study?: Array<Reference>;
     /** Encounter created as part of */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _date?: Element;
     /** The suspected agent causing the adverse event */
     suspectEntity?: Array<AdverseEventSuspectEntity>;
     /** AdverseEvent.referenceDocument */
     referenceDocument?: Array<Reference>;
     /** resolved | recovering | ongoing | resolvedWithSequelae | fatal | unknown */
-    outcome?: CodeableConcept;
+    outcome?: `${AdverseEventOutcome}`;
     /** When the event was recorded */
     recordedDate?: dateTime;
     /** Type of the event itself in relation to the subject */
@@ -37,24 +37,29 @@ export interface AdverseEvent extends DomainResource {
     subjectMedicalHistory?: Array<Reference>;
     _recordedDate?: Element;
     /** Who recorded the adverse event */
-    recorder?: Reference<"Patient" | "PractitionerRole" | "Practitioner" | "RelatedPerson">;
+    recorder?: Reference<'Patient' | 'PractitionerRole' | 'Practitioner' | 'RelatedPerson'>;
     /** Seriousness of the event */
     seriousness?: CodeableConcept;
     /** mild | moderate | severe */
-    severity?: CodeableConcept;
+    severity?: `${AdverseEventSeverity}`;
     /** Business identifier for the event */
     identifier?: Identifier;
     /** When the event was detected */
     detected?: dateTime;
     /** Location where adverse event occurred */
-    location?: Reference<"Location">;
+    location?: Reference<'Location'>;
     _detected?: Element;
     /** Subject impacted by event */
-    subject: Reference<"Patient" | "Practitioner" | "RelatedPerson" | "Group">;
+    subject: Reference<'Patient' | 'Practitioner' | 'RelatedPerson' | 'Group'>;
     _actuality?: Element;
     /** Effect on the subject due to this event */
     resultingCondition?: Array<Reference>;
 }
+/** actual | potential */
+export declare enum AdverseEventActuality {
+    Actual = "actual",
+    Potential = "potential"
+}
 /** Information on the possible cause of the event */
 export interface AdverseEventCausality extends BackboneElement {
     /** Assessment of if the entity caused the event */
@@ -63,14 +68,29 @@ export interface AdverseEventCausality extends BackboneElement {
     productRelatedness?: string;
     _productRelatedness?: Element;
     /** AdverseEvent.suspectEntity.causalityAuthor */
-    author?: Reference<"PractitionerRole" | "Practitioner">;
+    author?: Reference<'PractitionerRole' | 'Practitioner'>;
     /** ProbabilityScale | Bayesian | Checklist */
     method?: CodeableConcept;
 }
 /** The suspected agent causing the adverse event */
 export interface AdverseEventSuspectEntity extends BackboneElement {
     /** Refers to the specific entity that caused the adverse event */
-    instance: Reference<"MedicationAdministration" | "Medication" | "Device" | "Substance" | "Procedure" | "Immunization" | "MedicationStatement">;
+    instance: Reference<'MedicationAdministration' | 'Medication' | 'Device' | 'Substance' | 'Procedure' | 'Immunization' | 'MedicationStatement'>;
     /** Information on the possible cause of the event */
     causality?: Array<AdverseEventCausality>;
 }
+/** resolved | recovering | ongoing | resolvedWithSequelae | fatal | unknown */
+export declare enum AdverseEventOutcome {
+    Fatal = "fatal",
+    Ongoing = "ongoing",
+    Recovering = "recovering",
+    Resolved = "resolved",
+    ResolvedWithSequelae = "resolvedWithSequelae",
+    Unknown = "unknown"
+}
+/** mild | moderate | severe */
+export declare enum AdverseEventSeverity {
+    Mild = "mild",
+    Moderate = "moderate",
+    Severe = "severe"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/AdverseEvent.js b/vendor/r4/types/hl7-fhir-r4-core/AdverseEvent.js
index c8ad2e5..2231ed7 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/AdverseEvent.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/AdverseEvent.js
@@ -1,2 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdverseEventSeverity = exports.AdverseEventOutcome = exports.AdverseEventActuality = void 0;
+/** actual | potential */
+var AdverseEventActuality;
+(function (AdverseEventActuality) {
+    AdverseEventActuality["Actual"] = "actual";
+    AdverseEventActuality["Potential"] = "potential";
+})(AdverseEventActuality = exports.AdverseEventActuality || (exports.AdverseEventActuality = {}));
+/** resolved | recovering | ongoing | resolvedWithSequelae | fatal | unknown */
+var AdverseEventOutcome;
+(function (AdverseEventOutcome) {
+    AdverseEventOutcome["Fatal"] = "fatal";
+    AdverseEventOutcome["Ongoing"] = "ongoing";
+    AdverseEventOutcome["Recovering"] = "recovering";
+    AdverseEventOutcome["Resolved"] = "resolved";
+    AdverseEventOutcome["ResolvedWithSequelae"] = "resolvedWithSequelae";
+    AdverseEventOutcome["Unknown"] = "unknown";
+})(AdverseEventOutcome = exports.AdverseEventOutcome || (exports.AdverseEventOutcome = {}));
+/** mild | moderate | severe */
+var AdverseEventSeverity;
+(function (AdverseEventSeverity) {
+    AdverseEventSeverity["Mild"] = "mild";
+    AdverseEventSeverity["Moderate"] = "moderate";
+    AdverseEventSeverity["Severe"] = "severe";
+})(AdverseEventSeverity = exports.AdverseEventSeverity || (exports.AdverseEventSeverity = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/AllergyIntolerance.d.ts b/vendor/r4/types/hl7-fhir-r4-core/AllergyIntolerance.d.ts
index e12c53d..360f802 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/AllergyIntolerance.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/AllergyIntolerance.d.ts
@@ -14,25 +14,26 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. */
 export interface AllergyIntolerance extends DomainResource {
+    resourceType: 'AllergyIntolerance';
     /** Who the sensitivity is for */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** food | medication | environment | biologic */
     category?: Array<code>;
     _onsetString?: Element;
     /** low | high | unable-to-assess */
-    criticality?: code;
+    criticality?: `${AllergyIntoleranceCriticality}`;
     /** active | inactive | resolved */
-    clinicalStatus?: CodeableConcept;
+    clinicalStatus?: `${AllergyIntoleranceClinicalStatus}`;
     onsetRange?: Range;
     onsetAge?: Age;
     /** Encounter when the allergy or intolerance was asserted */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _type?: Element;
     onsetPeriod?: Period;
     /** allergy | intolerance - Underlying mechanism (if known) */
-    type?: code;
+    type?: `${AllergyIntoleranceType}`;
     /** Source of the information about the allergy */
-    asserter?: Reference<"Patient" | "PractitionerRole" | "Practitioner" | "RelatedPerson">;
+    asserter?: Reference<'Patient' | 'PractitionerRole' | 'Practitioner' | 'RelatedPerson'>;
     /** Additional text not captured in other fields */
     note?: Array<Annotation>;
     /** Date first version of the resource instance was recorded */
@@ -40,7 +41,7 @@ export interface AllergyIntolerance extends DomainResource {
     _recordedDate?: Element;
     onsetString?: string;
     /** Who recorded the sensitivity */
-    recorder?: Reference<"Patient" | "PractitionerRole" | "Practitioner" | "RelatedPerson">;
+    recorder?: Reference<'Patient' | 'PractitionerRole' | 'Practitioner' | 'RelatedPerson'>;
     /** Code that identifies the allergy or intolerance */
     code?: CodeableConcept;
     /** External ids for this item */
@@ -52,11 +53,42 @@ export interface AllergyIntolerance extends DomainResource {
     lastOccurrence?: dateTime;
     _onsetDateTime?: Element;
     /** unconfirmed | confirmed | refuted | entered-in-error */
-    verificationStatus?: CodeableConcept;
+    verificationStatus?: `${AllergyIntoleranceVerificationStatus}`;
     /** Adverse Reaction Events linked to exposure to substance */
     reaction?: Array<AllergyIntoleranceReaction>;
     _lastOccurrence?: Element;
 }
+/** low | high | unable-to-assess */
+export declare enum AllergyIntoleranceCriticality {
+    High = "high",
+    Low = "low",
+    UnableToAssess = "unable-to-assess"
+}
+/** active | inactive | resolved */
+export declare enum AllergyIntoleranceClinicalStatus {
+    Active = "active",
+    Inactive = "inactive",
+    Resolved = "resolved"
+}
+/** allergy | intolerance - Underlying mechanism (if known) */
+export declare enum AllergyIntoleranceType {
+    Allergy = "allergy",
+    Intolerance = "intolerance"
+}
+/** unconfirmed | confirmed | refuted | entered-in-error */
+export declare enum AllergyIntoleranceVerificationStatus {
+    Confirmed = "confirmed",
+    EnteredInError = "entered-in-error",
+    Presumed = "presumed",
+    Refuted = "refuted",
+    Unconfirmed = "unconfirmed"
+}
+/** mild | moderate | severe (of event as a whole) */
+export declare enum AllergyIntoleranceSeverity {
+    Mild = "mild",
+    Moderate = "moderate",
+    Severe = "severe"
+}
 /** Adverse Reaction Events linked to exposure to substance */
 export interface AllergyIntoleranceReaction extends BackboneElement {
     /** Description of the event as a whole */
@@ -74,6 +106,6 @@ export interface AllergyIntoleranceReaction extends BackboneElement {
     /** Specific substance or pharmaceutical product considered to be responsible for event */
     substance?: CodeableConcept;
     /** mild | moderate | severe (of event as a whole) */
-    severity?: code;
+    severity?: `${AllergyIntoleranceSeverity}`;
     _severity?: Element;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/AllergyIntolerance.js b/vendor/r4/types/hl7-fhir-r4-core/AllergyIntolerance.js
index c8ad2e5..74e5f03 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/AllergyIntolerance.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/AllergyIntolerance.js
@@ -1,2 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllergyIntoleranceSeverity = exports.AllergyIntoleranceVerificationStatus = exports.AllergyIntoleranceType = exports.AllergyIntoleranceClinicalStatus = exports.AllergyIntoleranceCriticality = void 0;
+/** low | high | unable-to-assess */
+var AllergyIntoleranceCriticality;
+(function (AllergyIntoleranceCriticality) {
+    AllergyIntoleranceCriticality["High"] = "high";
+    AllergyIntoleranceCriticality["Low"] = "low";
+    AllergyIntoleranceCriticality["UnableToAssess"] = "unable-to-assess";
+})(AllergyIntoleranceCriticality = exports.AllergyIntoleranceCriticality || (exports.AllergyIntoleranceCriticality = {}));
+/** active | inactive | resolved */
+var AllergyIntoleranceClinicalStatus;
+(function (AllergyIntoleranceClinicalStatus) {
+    AllergyIntoleranceClinicalStatus["Active"] = "active";
+    AllergyIntoleranceClinicalStatus["Inactive"] = "inactive";
+    AllergyIntoleranceClinicalStatus["Resolved"] = "resolved";
+})(AllergyIntoleranceClinicalStatus = exports.AllergyIntoleranceClinicalStatus || (exports.AllergyIntoleranceClinicalStatus = {}));
+/** allergy | intolerance - Underlying mechanism (if known) */
+var AllergyIntoleranceType;
+(function (AllergyIntoleranceType) {
+    AllergyIntoleranceType["Allergy"] = "allergy";
+    AllergyIntoleranceType["Intolerance"] = "intolerance";
+})(AllergyIntoleranceType = exports.AllergyIntoleranceType || (exports.AllergyIntoleranceType = {}));
+/** unconfirmed | confirmed | refuted | entered-in-error */
+var AllergyIntoleranceVerificationStatus;
+(function (AllergyIntoleranceVerificationStatus) {
+    AllergyIntoleranceVerificationStatus["Confirmed"] = "confirmed";
+    AllergyIntoleranceVerificationStatus["EnteredInError"] = "entered-in-error";
+    AllergyIntoleranceVerificationStatus["Presumed"] = "presumed";
+    AllergyIntoleranceVerificationStatus["Refuted"] = "refuted";
+    AllergyIntoleranceVerificationStatus["Unconfirmed"] = "unconfirmed";
+})(AllergyIntoleranceVerificationStatus = exports.AllergyIntoleranceVerificationStatus || (exports.AllergyIntoleranceVerificationStatus = {}));
+/** mild | moderate | severe (of event as a whole) */
+var AllergyIntoleranceSeverity;
+(function (AllergyIntoleranceSeverity) {
+    AllergyIntoleranceSeverity["Mild"] = "mild";
+    AllergyIntoleranceSeverity["Moderate"] = "moderate";
+    AllergyIntoleranceSeverity["Severe"] = "severe";
+})(AllergyIntoleranceSeverity = exports.AllergyIntoleranceSeverity || (exports.AllergyIntoleranceSeverity = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Annotation.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Annotation.d.ts
index 13f7586..90ba2c6 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Annotation.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Annotation.d.ts
@@ -6,7 +6,7 @@ import { Element } from "./Element";
 import { Reference } from "./Reference";
 /** Base StructureDefinition for Annotation Type: A  text note which also  contains information about who made the statement and when. */
 export interface Annotation extends Element {
-    authorReference?: Reference<"Patient" | "Organization" | "Practitioner" | "RelatedPerson">;
+    authorReference?: Reference<'Patient' | 'Organization' | 'Practitioner' | 'RelatedPerson'>;
     authorString?: string;
     _authorString?: Element;
     /** When the annotation was made */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Appointment.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Appointment.d.ts
index e209c45..c2c9a65 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Appointment.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Appointment.d.ts
@@ -9,11 +9,11 @@ import { DomainResource } from "./DomainResource";
 import { instant } from "./instant";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s). */
 export interface Appointment extends DomainResource {
+    resourceType: 'Appointment';
     _created?: Element;
     /** Shown on a subject line in a meeting request, or appointment list */
     description?: string;
@@ -51,7 +51,7 @@ export interface Appointment extends DomainResource {
     /** The style of appointment or patient that has been booked in the slot (not service type) */
     appointmentType?: CodeableConcept;
     /** proposed | pending | booked | arrived | fulfilled | cancelled | noshow | entered-in-error | checked-in | waitlist */
-    status: code;
+    status: `${AppointmentStatus}`;
     /** Additional comments */
     comment?: string;
     /** Can be less than start/end (e.g. estimate) */
@@ -68,17 +68,36 @@ export interface Appointment extends DomainResource {
     /** Reason the appointment is to take place (resource) */
     reasonReference?: Array<Reference>;
 }
+/** required | optional | information-only */
+export declare enum AppointmentRequired {
+    InformationOnly = "information-only",
+    Optional = "optional",
+    Required = "required"
+}
+/** proposed | pending | booked | arrived | fulfilled | cancelled | noshow | entered-in-error | checked-in | waitlist */
+export declare enum AppointmentStatus {
+    Fulfilled = "fulfilled",
+    Proposed = "proposed",
+    Cancelled = "cancelled",
+    Arrived = "arrived",
+    CheckedIn = "checked-in",
+    Noshow = "noshow",
+    EnteredInError = "entered-in-error",
+    Booked = "booked",
+    Pending = "pending",
+    Waitlist = "waitlist"
+}
 /** Participants involved in appointment */
 export interface AppointmentParticipant extends BackboneElement {
     /** Role of participant in the appointment */
     type?: Array<CodeableConcept>;
     /** Person, Location/HealthcareService or Device */
-    actor?: Reference<"Patient" | "PractitionerRole" | "HealthcareService" | "Device" | "Location" | "Practitioner" | "RelatedPerson">;
+    actor?: Reference<'Patient' | 'PractitionerRole' | 'HealthcareService' | 'Device' | 'Location' | 'Practitioner' | 'RelatedPerson'>;
     /** required | optional | information-only */
-    required?: code;
+    required?: `${AppointmentRequired}`;
     _required?: Element;
     /** accepted | declined | tentative | needs-action */
-    status: code;
+    status: `${AppointmentStatus}`;
     _status?: Element;
     /** Participation period of the actor */
     period?: Period;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Appointment.js b/vendor/r4/types/hl7-fhir-r4-core/Appointment.js
index c8ad2e5..21d2cc0 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Appointment.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Appointment.js
@@ -1,2 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentStatus = exports.AppointmentRequired = void 0;
+/** required | optional | information-only */
+var AppointmentRequired;
+(function (AppointmentRequired) {
+    AppointmentRequired["InformationOnly"] = "information-only";
+    AppointmentRequired["Optional"] = "optional";
+    AppointmentRequired["Required"] = "required";
+})(AppointmentRequired = exports.AppointmentRequired || (exports.AppointmentRequired = {}));
+/** proposed | pending | booked | arrived | fulfilled | cancelled | noshow | entered-in-error | checked-in | waitlist */
+var AppointmentStatus;
+(function (AppointmentStatus) {
+    AppointmentStatus["Fulfilled"] = "fulfilled";
+    AppointmentStatus["Proposed"] = "proposed";
+    AppointmentStatus["Cancelled"] = "cancelled";
+    AppointmentStatus["Arrived"] = "arrived";
+    AppointmentStatus["CheckedIn"] = "checked-in";
+    AppointmentStatus["Noshow"] = "noshow";
+    AppointmentStatus["EnteredInError"] = "entered-in-error";
+    AppointmentStatus["Booked"] = "booked";
+    AppointmentStatus["Pending"] = "pending";
+    AppointmentStatus["Waitlist"] = "waitlist";
+})(AppointmentStatus = exports.AppointmentStatus || (exports.AppointmentStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/AppointmentResponse.d.ts b/vendor/r4/types/hl7-fhir-r4-core/AppointmentResponse.d.ts
index f52c740..e6c3163 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/AppointmentResponse.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/AppointmentResponse.d.ts
@@ -5,17 +5,17 @@ import { DomainResource } from "./DomainResource";
 import { instant } from "./instant";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection. */
 export interface AppointmentResponse extends DomainResource {
+    resourceType: 'AppointmentResponse';
     /** Appointment this response relates to */
-    appointment: Reference<"Appointment">;
+    appointment: Reference<'Appointment'>;
     _end?: Element;
     /** Time from appointment, or requested new start time */
     start?: instant;
     /** accepted | declined | tentative | needs-action */
-    participantStatus: code;
+    participantStatus: `${AppointmentResponseParticipantStatus}`;
     /** Role of participant in the appointment */
     participantType?: Array<CodeableConcept>;
     /** Additional comments */
@@ -28,5 +28,12 @@ export interface AppointmentResponse extends DomainResource {
     _start?: Element;
     _comment?: Element;
     /** Person, Location, HealthcareService, or Device */
-    actor?: Reference<"Patient" | "PractitionerRole" | "HealthcareService" | "Device" | "Location" | "Practitioner" | "RelatedPerson">;
+    actor?: Reference<'Patient' | 'PractitionerRole' | 'HealthcareService' | 'Device' | 'Location' | 'Practitioner' | 'RelatedPerson'>;
+}
+/** accepted | declined | tentative | needs-action */
+export declare enum AppointmentResponseParticipantStatus {
+    Accepted = "accepted",
+    Declined = "declined",
+    NeedsAction = "needs-action",
+    Tentative = "tentative"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/AppointmentResponse.js b/vendor/r4/types/hl7-fhir-r4-core/AppointmentResponse.js
index c8ad2e5..d953752 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/AppointmentResponse.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/AppointmentResponse.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentResponseParticipantStatus = void 0;
+/** accepted | declined | tentative | needs-action */
+var AppointmentResponseParticipantStatus;
+(function (AppointmentResponseParticipantStatus) {
+    AppointmentResponseParticipantStatus["Accepted"] = "accepted";
+    AppointmentResponseParticipantStatus["Declined"] = "declined";
+    AppointmentResponseParticipantStatus["NeedsAction"] = "needs-action";
+    AppointmentResponseParticipantStatus["Tentative"] = "tentative";
+})(AppointmentResponseParticipantStatus = exports.AppointmentResponseParticipantStatus || (exports.AppointmentResponseParticipantStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Attachment.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Attachment.d.ts
index 28c623a..e056061 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Attachment.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Attachment.d.ts
@@ -28,8 +28,15 @@ export interface Attachment extends Element {
     url?: url;
     _title?: Element;
     /** Mime type of the content, with charset etc. */
-    contentType?: code;
+    contentType?: `${AttachmentContentType}`;
     _url?: Element;
     /** Data inline, base64ed */
     data?: base64Binary;
 }
+/** Mime type of the content, with charset etc. */
+export declare enum AttachmentContentType {
+    "Application/hl7Cda+xml" = "application/hl7-cda+xml",
+    "Application/sparqlResults+xml" = "application/sparql-results+xml",
+    "Application/sql" = "application/sql",
+    "Application/xquery" = "application/xquery"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Attachment.js b/vendor/r4/types/hl7-fhir-r4-core/Attachment.js
index c8ad2e5..cafe52a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Attachment.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Attachment.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentContentType = void 0;
+/** Mime type of the content, with charset etc. */
+var AttachmentContentType;
+(function (AttachmentContentType) {
+    AttachmentContentType["Application/hl7Cda+xml"] = "application/hl7-cda+xml";
+    AttachmentContentType["Application/sparqlResults+xml"] = "application/sparql-results+xml";
+    AttachmentContentType["Application/sql"] = "application/sql";
+    AttachmentContentType["Application/xquery"] = "application/xquery";
+})(AttachmentContentType = exports.AttachmentContentType || (exports.AttachmentContentType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/AuditEvent.d.ts b/vendor/r4/types/hl7-fhir-r4-core/AuditEvent.d.ts
index 720f171..e7ecf5f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/AuditEvent.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/AuditEvent.d.ts
@@ -9,17 +9,17 @@ import { base64Binary } from "./base64Binary";
 import { instant } from "./instant";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** A record of an event made for purposes of maintaining a security log. Typical uses include detection of intrusion attempts and monitoring for inappropriate usage. */
 export interface AuditEvent extends DomainResource {
+    resourceType: 'AuditEvent';
     /** Description of the event outcome */
     outcomeDesc?: string;
     _action?: Element;
     /** Type/identifier of event */
     type: Coding;
     /** Whether the event succeeded or failed */
-    outcome?: code;
+    outcome?: `${AuditEventOutcome}`;
     /** Audit Event Reporter */
     source: AuditEventSource;
     /** Time when the event was recorded */
@@ -30,7 +30,7 @@ export interface AuditEvent extends DomainResource {
     /** The purposeOfUse of the event */
     purposeOfEvent?: Array<CodeableConcept>;
     /** Type of action performed during the event */
-    action?: code;
+    action?: `${AuditEventAction}`;
     _outcomeDesc?: Element;
     /** When the activity occurred */
     period?: Period;
@@ -40,23 +40,38 @@ export interface AuditEvent extends DomainResource {
     /** More specific type/id for the event */
     subtype?: Array<Coding>;
 }
+/** Whether the event succeeded or failed */
+export declare enum AuditEventOutcome {
+    Num0 = "0",
+    Num12 = "12",
+    Num4 = "4",
+    Num8 = "8"
+}
 /** Audit Event Reporter */
 export interface AuditEventSource extends BackboneElement {
     /** Logical source location within the enterprise */
     site?: string;
     _site?: Element;
     /** The identity of source detecting the event */
-    observer: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    observer: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** The type of source where event originated */
     type?: Array<Coding>;
 }
+/** The type of network access point */
+export declare enum AuditEventType {
+    Num1 = "1",
+    Num2 = "2",
+    Num3 = "3",
+    Num4 = "4",
+    Num5 = "5"
+}
 /** Logical network location for application activity */
 export interface AuditEventNetwork extends BackboneElement {
     /** Identifier for the network access point of the user device */
     address?: string;
     _address?: Element;
     /** The type of network access point */
-    type?: code;
+    type?: `${AuditEventType}`;
     _type?: Element;
 }
 /** Actor involved in the event */
@@ -66,7 +81,7 @@ export interface AuditEventAgent extends BackboneElement {
     /** Whether user is initiator */
     requestor: boolean;
     /** Identifier of who */
-    who?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    who?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** Alternative User identity */
     altId?: string;
     /** Human friendly name for the agent */
@@ -83,11 +98,19 @@ export interface AuditEventAgent extends BackboneElement {
     /** Logical network location for application activity */
     network?: AuditEventNetwork;
     /** Where */
-    location?: Reference<"Location">;
+    location?: Reference<'Location'>;
     /** Type of media */
     media?: Coding;
     _requestor?: Element;
 }
+/** Type of action performed during the event */
+export declare enum AuditEventAction {
+    C = "C",
+    D = "D",
+    E = "E",
+    R = "R",
+    U = "U"
+}
 /** Additional Information about the entity */
 export interface AuditEventDetail extends BackboneElement {
     /** Name of the property */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/AuditEvent.js b/vendor/r4/types/hl7-fhir-r4-core/AuditEvent.js
index c8ad2e5..0470b46 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/AuditEvent.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/AuditEvent.js
@@ -1,2 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditEventAction = exports.AuditEventType = exports.AuditEventOutcome = void 0;
+/** Whether the event succeeded or failed */
+var AuditEventOutcome;
+(function (AuditEventOutcome) {
+    AuditEventOutcome["Num0"] = "0";
+    AuditEventOutcome["Num12"] = "12";
+    AuditEventOutcome["Num4"] = "4";
+    AuditEventOutcome["Num8"] = "8";
+})(AuditEventOutcome = exports.AuditEventOutcome || (exports.AuditEventOutcome = {}));
+/** The type of network access point */
+var AuditEventType;
+(function (AuditEventType) {
+    AuditEventType["Num1"] = "1";
+    AuditEventType["Num2"] = "2";
+    AuditEventType["Num3"] = "3";
+    AuditEventType["Num4"] = "4";
+    AuditEventType["Num5"] = "5";
+})(AuditEventType = exports.AuditEventType || (exports.AuditEventType = {}));
+/** Type of action performed during the event */
+var AuditEventAction;
+(function (AuditEventAction) {
+    AuditEventAction["C"] = "C";
+    AuditEventAction["D"] = "D";
+    AuditEventAction["E"] = "E";
+    AuditEventAction["R"] = "R";
+    AuditEventAction["U"] = "U";
+})(AuditEventAction = exports.AuditEventAction || (exports.AuditEventAction = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Basic.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Basic.d.ts
index dae2f94..b3c9a6d 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Basic.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Basic.d.ts
@@ -8,6 +8,7 @@ import { Reference } from "./Reference";
 import { Identifier } from "./Identifier";
 /** Basic is used for handling concepts not yet defined in FHIR, narrative-only resources that don't map to an existing resource, and custom resources not appropriate for inclusion in the FHIR specification. */
 export interface Basic extends DomainResource {
+    resourceType: 'Basic';
     /** Business identifier */
     identifier?: Array<Identifier>;
     /** Kind of Resource */
@@ -18,5 +19,5 @@ export interface Basic extends DomainResource {
     created?: date;
     _created?: Element;
     /** Who created */
-    author?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Practitioner" | "RelatedPerson">;
+    author?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Practitioner' | 'RelatedPerson'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Binary.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Binary.d.ts
index 7e534a9..6ae3ac8 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Binary.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Binary.d.ts
@@ -4,11 +4,11 @@ import { Resource } from "./Resource";
 import { base64Binary } from "./base64Binary";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 /** A resource that represents the data of a single raw artifact as digital content accessible in its native format.  A Binary resource can contain any content, whether text, image, pdf, zip archive, etc. */
 export interface Binary extends Resource {
+    resourceType: 'Binary';
     /** MimeType of the binary content */
-    contentType: code;
+    contentType: `${BinaryContentType}`;
     _contentType?: Element;
     /** Identifies another resource to use as proxy when enforcing access control */
     securityContext?: Reference;
@@ -16,3 +16,10 @@ export interface Binary extends Resource {
     data?: base64Binary;
     _data?: Element;
 }
+/** MimeType of the binary content */
+export declare enum BinaryContentType {
+    "Application/hl7Cda+xml" = "application/hl7-cda+xml",
+    "Application/sparqlResults+xml" = "application/sparql-results+xml",
+    "Application/sql" = "application/sql",
+    "Application/xquery" = "application/xquery"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Binary.js b/vendor/r4/types/hl7-fhir-r4-core/Binary.js
index c8ad2e5..b230208 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Binary.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Binary.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryContentType = void 0;
+/** MimeType of the binary content */
+var BinaryContentType;
+(function (BinaryContentType) {
+    BinaryContentType["Application/hl7Cda+xml"] = "application/hl7-cda+xml";
+    BinaryContentType["Application/sparqlResults+xml"] = "application/sparql-results+xml";
+    BinaryContentType["Application/sql"] = "application/sql";
+    BinaryContentType["Application/xquery"] = "application/xquery";
+})(BinaryContentType = exports.BinaryContentType || (exports.BinaryContentType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/BiologicallyDerivedProduct.d.ts b/vendor/r4/types/hl7-fhir-r4-core/BiologicallyDerivedProduct.d.ts
index a0a7563..a22b512 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/BiologicallyDerivedProduct.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/BiologicallyDerivedProduct.d.ts
@@ -7,13 +7,13 @@ import { integer } from "./integer";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** A material substance originating from a biological entity intended to be transplanted or infused
 into another (possibly the same) biological entity. */
 export interface BiologicallyDerivedProduct extends DomainResource {
+    resourceType: 'BiologicallyDerivedProduct';
     _quantity?: Element;
     /** Procedure request */
     request?: Array<Reference>;
@@ -24,7 +24,7 @@ export interface BiologicallyDerivedProduct extends DomainResource {
     parent?: Array<Reference>;
     _status?: Element;
     /** available | unavailable */
-    status?: code;
+    status?: `${BiologicallyDerivedProductStatus}`;
     /** External ids for this item */
     identifier?: Array<Identifier>;
     /** What this biologically derived product is */
@@ -34,7 +34,7 @@ export interface BiologicallyDerivedProduct extends DomainResource {
     /** The amount of this biologically derived product */
     quantity?: integer;
     /** organ | tissue | fluid | cells | biologicalAgent */
-    productCategory?: code;
+    productCategory?: `${BiologicallyDerivedProductProductCategory}`;
     /** Any manipulation of product post-collection */
     manipulation?: BiologicallyDerivedProductManipulation;
     /** How this product was collected */
@@ -48,11 +48,22 @@ export interface BiologicallyDerivedProductProcessing extends BackboneElement {
     /** Procesing code */
     procedure?: CodeableConcept;
     /** Substance added during processing */
-    additive?: Reference<"Substance">;
+    additive?: Reference<'Substance'>;
     timeDateTime?: dateTime;
     _timeDateTime?: Element;
     timePeriod?: Period;
 }
+/** available | unavailable */
+export declare enum BiologicallyDerivedProductStatus {
+    Available = "available",
+    Unavailable = "unavailable"
+}
+/** farenheit | celsius | kelvin */
+export declare enum BiologicallyDerivedProductScale {
+    Celsius = "celsius",
+    Farenheit = "farenheit",
+    Kelvin = "kelvin"
+}
 /** Product storage */
 export interface BiologicallyDerivedProductStorage extends BackboneElement {
     /** Description of storage */
@@ -62,11 +73,19 @@ export interface BiologicallyDerivedProductStorage extends BackboneElement {
     temperature?: decimal;
     _temperature?: Element;
     /** farenheit | celsius | kelvin */
-    scale?: code;
+    scale?: `${BiologicallyDerivedProductScale}`;
     _scale?: Element;
     /** Storage timeperiod */
     duration?: Period;
 }
+/** organ | tissue | fluid | cells | biologicalAgent */
+export declare enum BiologicallyDerivedProductProductCategory {
+    BiologicalAgent = "biologicalAgent",
+    Cells = "cells",
+    Fluid = "fluid",
+    Organ = "organ",
+    Tissue = "tissue"
+}
 /** Any manipulation of product post-collection */
 export interface BiologicallyDerivedProductManipulation extends BackboneElement {
     /** Description of manipulation */
@@ -79,9 +98,9 @@ export interface BiologicallyDerivedProductManipulation extends BackboneElement
 /** How this product was collected */
 export interface BiologicallyDerivedProductCollection extends BackboneElement {
     /** Individual performing collection */
-    collector?: Reference<"PractitionerRole" | "Practitioner">;
+    collector?: Reference<'PractitionerRole' | 'Practitioner'>;
     /** Who is product from */
-    source?: Reference<"Patient" | "Organization">;
+    source?: Reference<'Patient' | 'Organization'>;
     collectedDateTime?: dateTime;
     _collectedDateTime?: Element;
     collectedPeriod?: Period;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/BiologicallyDerivedProduct.js b/vendor/r4/types/hl7-fhir-r4-core/BiologicallyDerivedProduct.js
index c8ad2e5..0c85406 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/BiologicallyDerivedProduct.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/BiologicallyDerivedProduct.js
@@ -1,2 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BiologicallyDerivedProductProductCategory = exports.BiologicallyDerivedProductScale = exports.BiologicallyDerivedProductStatus = void 0;
+/** available | unavailable */
+var BiologicallyDerivedProductStatus;
+(function (BiologicallyDerivedProductStatus) {
+    BiologicallyDerivedProductStatus["Available"] = "available";
+    BiologicallyDerivedProductStatus["Unavailable"] = "unavailable";
+})(BiologicallyDerivedProductStatus = exports.BiologicallyDerivedProductStatus || (exports.BiologicallyDerivedProductStatus = {}));
+/** farenheit | celsius | kelvin */
+var BiologicallyDerivedProductScale;
+(function (BiologicallyDerivedProductScale) {
+    BiologicallyDerivedProductScale["Celsius"] = "celsius";
+    BiologicallyDerivedProductScale["Farenheit"] = "farenheit";
+    BiologicallyDerivedProductScale["Kelvin"] = "kelvin";
+})(BiologicallyDerivedProductScale = exports.BiologicallyDerivedProductScale || (exports.BiologicallyDerivedProductScale = {}));
+/** organ | tissue | fluid | cells | biologicalAgent */
+var BiologicallyDerivedProductProductCategory;
+(function (BiologicallyDerivedProductProductCategory) {
+    BiologicallyDerivedProductProductCategory["BiologicalAgent"] = "biologicalAgent";
+    BiologicallyDerivedProductProductCategory["Cells"] = "cells";
+    BiologicallyDerivedProductProductCategory["Fluid"] = "fluid";
+    BiologicallyDerivedProductProductCategory["Organ"] = "organ";
+    BiologicallyDerivedProductProductCategory["Tissue"] = "tissue";
+})(BiologicallyDerivedProductProductCategory = exports.BiologicallyDerivedProductProductCategory || (exports.BiologicallyDerivedProductProductCategory = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/BodyStructure.d.ts b/vendor/r4/types/hl7-fhir-r4-core/BodyStructure.d.ts
index aa3a053..77e3a86 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/BodyStructure.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/BodyStructure.d.ts
@@ -8,8 +8,9 @@ import { Reference } from "./Reference";
 import { Identifier } from "./Identifier";
 /** Record details about an anatomical structure.  This resource may be used when a coded concept does not provide the necessary detail needed for the use case. */
 export interface BodyStructure extends DomainResource {
+    resourceType: 'BodyStructure';
     /** Who this is about */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** Text description */
     description?: string;
     _active?: Element;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Bundle.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Bundle.d.ts
index f28601b..73bb007 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Bundle.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Bundle.d.ts
@@ -6,18 +6,18 @@ import { Signature } from "./Signature";
 import { Resource } from "./Resource";
 import { instant } from "./instant";
 import { Element } from "./Element";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** A container for a collection of resources. */
 export interface Bundle extends Resource {
+    resourceType: 'Bundle';
     _timestamp?: Element;
     /** Digital Signature */
     signature?: Signature;
     _type?: Element;
     /** document | message | transaction | transaction-response | batch | batch-response | history | searchset | collection */
-    type: code;
+    type: `${BundleType}`;
     /** If search, the total number of matches */
     total?: unsignedInt;
     link?: Array<BundleLink>;
@@ -29,15 +29,42 @@ export interface Bundle extends Resource {
     timestamp?: instant;
     _total?: Element;
 }
+/** document | message | transaction | transaction-response | batch | batch-response | history | searchset | collection */
+export declare enum BundleType {
+    History = "history",
+    Batch = "batch",
+    TransactionResponse = "transaction-response",
+    Message = "message",
+    BatchResponse = "batch-response",
+    Searchset = "searchset",
+    Document = "document",
+    Transaction = "transaction",
+    Collection = "collection"
+}
+/** match | include | outcome - why this is in the result set */
+export declare enum BundleMode {
+    Include = "include",
+    Match = "match",
+    Outcome = "outcome"
+}
 /** Search related information */
 export interface BundleSearch extends BackboneElement {
     /** match | include | outcome - why this is in the result set */
-    mode?: code;
+    mode?: `${BundleMode}`;
     _mode?: Element;
     /** Search ranking (between 0 and 1) */
     score?: decimal;
     _score?: Element;
 }
+/** GET | HEAD | POST | PUT | DELETE | PATCH */
+export declare enum BundleMethod {
+    DELETE = "DELETE",
+    GET = "GET",
+    HEAD = "HEAD",
+    PATCH = "PATCH",
+    POST = "POST",
+    PUT = "PUT"
+}
 /** Additional execution information (transaction/batch/history) */
 export interface BundleRequest extends BackboneElement {
     /** For conditional creates */
@@ -45,7 +72,7 @@ export interface BundleRequest extends BackboneElement {
     _ifNoneMatch?: Element;
     _ifNoneExist?: Element;
     /** GET | HEAD | POST | PUT | DELETE | PATCH */
-    method: code;
+    method: `${BundleMethod}`;
     /** For managing cache currency */
     ifModifiedSince?: instant;
     _ifMatch?: Element;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Bundle.js b/vendor/r4/types/hl7-fhir-r4-core/Bundle.js
index c8ad2e5..3832c15 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Bundle.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Bundle.js
@@ -1,2 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundleMethod = exports.BundleMode = exports.BundleType = void 0;
+/** document | message | transaction | transaction-response | batch | batch-response | history | searchset | collection */
+var BundleType;
+(function (BundleType) {
+    BundleType["History"] = "history";
+    BundleType["Batch"] = "batch";
+    BundleType["TransactionResponse"] = "transaction-response";
+    BundleType["Message"] = "message";
+    BundleType["BatchResponse"] = "batch-response";
+    BundleType["Searchset"] = "searchset";
+    BundleType["Document"] = "document";
+    BundleType["Transaction"] = "transaction";
+    BundleType["Collection"] = "collection";
+})(BundleType = exports.BundleType || (exports.BundleType = {}));
+/** match | include | outcome - why this is in the result set */
+var BundleMode;
+(function (BundleMode) {
+    BundleMode["Include"] = "include";
+    BundleMode["Match"] = "match";
+    BundleMode["Outcome"] = "outcome";
+})(BundleMode = exports.BundleMode || (exports.BundleMode = {}));
+/** GET | HEAD | POST | PUT | DELETE | PATCH */
+var BundleMethod;
+(function (BundleMethod) {
+    BundleMethod["DELETE"] = "DELETE";
+    BundleMethod["GET"] = "GET";
+    BundleMethod["HEAD"] = "HEAD";
+    BundleMethod["PATCH"] = "PATCH";
+    BundleMethod["POST"] = "POST";
+    BundleMethod["PUT"] = "PUT";
+})(BundleMethod = exports.BundleMethod || (exports.BundleMethod = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CapabilityStatement.d.ts b/vendor/r4/types/hl7-fhir-r4-core/CapabilityStatement.d.ts
index 663c61f..60f9390 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CapabilityStatement.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/CapabilityStatement.d.ts
@@ -17,6 +17,7 @@ import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation. */
 export interface CapabilityStatement extends DomainResource {
+    resourceType: 'CapabilityStatement';
     /** Natural language description of the capability statement */
     description?: markdown;
     _kind?: Element;
@@ -32,7 +33,7 @@ export interface CapabilityStatement extends DomainResource {
     /** Patch formats supported */
     patchFormat?: Array<code>;
     /** FHIR Version the system supports */
-    fhirVersion: code;
+    fhirVersion: `${CapabilityStatementFhirVersion}`;
     /** Intended jurisdiction for capability statement (if applicable) */
     jurisdiction?: Array<CodeableConcept>;
     _publisher?: Element;
@@ -62,11 +63,11 @@ export interface CapabilityStatement extends DomainResource {
     document?: Array<CapabilityStatementDocument>;
     _purpose?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${CapabilityStatementStatus}`;
     /** If messaging is supported */
     messaging?: Array<CapabilityStatementMessaging>;
     /** instance | capability | requirements */
-    kind: code;
+    kind: `${CapabilityStatementKind}`;
     _name?: Element;
     /** Implementation guides supported */
     implementationGuide?: Array<canonical>;
@@ -97,12 +98,18 @@ export interface CapabilityStatementRestResourceSearchParam extends BackboneElem
     definition?: canonical;
     _definition?: Element;
     /** number | date | string | token | reference | composite | quantity | uri | special */
-    type: code;
+    type: `${CapabilityStatementRestResourceSearchParamType}`;
     _type?: Element;
     /** Server-specific usage */
     documentation?: markdown;
     _documentation?: Element;
 }
+/** not-supported | single | multiple - how conditional delete is supported */
+export declare enum CapabilityStatementConditionalDelete {
+    Multiple = "multiple",
+    NotSupported = "not-supported",
+    Single = "single"
+}
 /** Where messages should be sent */
 export interface CapabilityStatementEndpoint extends BackboneElement {
     /** http | ftp | mllp + */
@@ -111,15 +118,40 @@ export interface CapabilityStatementEndpoint extends BackboneElement {
     address: url;
     _address?: Element;
 }
+/** no-version | versioned | versioned-update */
+export declare enum CapabilityStatementVersioning {
+    NoVersion = "no-version",
+    Versioned = "versioned",
+    VersionedUpdate = "versioned-update"
+}
 /** What operations are supported? */
 export interface CapabilityStatementInteraction extends BackboneElement {
     /** transaction | batch | search-system | history-system */
-    code: code;
+    code: `${CapabilityStatementCode}`;
     _code?: Element;
     /** Anything special about operation behavior */
     documentation?: markdown;
     _documentation?: Element;
 }
+/** not-supported | modified-since | not-match | full-support */
+export declare enum CapabilityStatementConditionalRead {
+    FullSupport = "full-support",
+    ModifiedSince = "modified-since",
+    NotMatch = "not-match",
+    NotSupported = "not-supported"
+}
+/** read | vread | update | patch | delete | history-instance | history-type | create | search-type */
+export declare enum CapabilityStatementCode {
+    SearchType = "search-type",
+    HistoryType = "history-type",
+    Delete = "delete",
+    Update = "update",
+    Read = "read",
+    Create = "create",
+    Vread = "vread",
+    HistoryInstance = "history-instance",
+    Patch = "patch"
+}
 /** If this describes a specific instance */
 export interface CapabilityStatementImplementation extends BackboneElement {
     /** Describes this specific instance */
@@ -129,12 +161,12 @@ export interface CapabilityStatementImplementation extends BackboneElement {
     url?: url;
     _url?: Element;
     /** Organization that manages the data */
-    custodian?: Reference<"Organization">;
+    custodian?: Reference<'Organization'>;
 }
 /** Messages supported by this system */
 export interface CapabilityStatementSupportedMessage extends BackboneElement {
     /** sender | receiver */
-    mode: code;
+    mode: `${CapabilityStatementMode}`;
     _mode?: Element;
     /** Message supported by this system */
     definition: canonical;
@@ -151,10 +183,27 @@ export interface CapabilityStatementSecurity extends BackboneElement {
     description?: markdown;
     _description?: Element;
 }
+/** number | date | string | token | reference | composite | quantity | uri | special */
+export declare enum CapabilityStatementRestResourceSearchParamType {
+    Uri = "uri",
+    Number = "number",
+    Date = "date",
+    Special = "special",
+    Quantity = "quantity",
+    String = "string",
+    Composite = "composite",
+    Token = "token",
+    Reference = "reference"
+}
+/** client | server */
+export declare enum CapabilityStatementMode {
+    Client = "client",
+    Server = "server"
+}
 /** Document definition */
 export interface CapabilityStatementDocument extends BackboneElement {
     /** producer | consumer */
-    mode: code;
+    mode: `${CapabilityStatementMode}`;
     _mode?: Element;
     /** Description of document support */
     documentation?: markdown;
@@ -173,7 +222,7 @@ export interface CapabilityStatementRest extends BackboneElement {
     /** Definition of a system level operation */
     operation?: Array<CapabilityStatementRestResourceOperation>;
     /** client | server */
-    mode: code;
+    mode: `${CapabilityStatementMode}`;
     _compartment?: Array<Element>;
     /** What operations are supported? */
     interaction?: Array<CapabilityStatementInteraction>;
@@ -197,6 +246,182 @@ export interface CapabilityStatementRestResourceOperation extends BackboneElemen
     documentation?: markdown;
     _documentation?: Element;
 }
+/** FHIR Version the system supports */
+export declare enum CapabilityStatementFhirVersion {
+    "Num1.8.0" = "1.8.0",
+    "Num0.05" = "0.05",
+    "Num0.01" = "0.01",
+    "Num3.0.1" = "3.0.1",
+    "Num1.0.0" = "1.0.0",
+    "Num3.3.0" = "3.3.0",
+    "Num0.0.82" = "0.0.82",
+    "Num1.6.0" = "1.6.0",
+    "Num1.4.0" = "1.4.0",
+    "Num3.0.0" = "3.0.0",
+    "Num0.0.80" = "0.0.80",
+    "Num4.0.0" = "4.0.0",
+    "Num0.11" = "0.11",
+    "Num0.06" = "0.06",
+    "Num1.0.2" = "1.0.2",
+    "Num1.0.1" = "1.0.1",
+    "Num0.4.0" = "0.4.0",
+    "Num4.0.1" = "4.0.1",
+    "Num3.5.0" = "3.5.0",
+    "Num0.5.0" = "0.5.0",
+    "Num1.1.0" = "1.1.0",
+    "Num0.0.81" = "0.0.81"
+}
+/** A resource type that is supported */
+export declare enum CapabilityStatementType {
+    ImmunizationEvaluation = "ImmunizationEvaluation",
+    Appointment = "Appointment",
+    StructureMap = "StructureMap",
+    CareTeam = "CareTeam",
+    Linkage = "Linkage",
+    Communication = "Communication",
+    MedicationDispense = "MedicationDispense",
+    ImagingStudy = "ImagingStudy",
+    ChargeItem = "ChargeItem",
+    AdverseEvent = "AdverseEvent",
+    Media = "Media",
+    SubstancePolymer = "SubstancePolymer",
+    QuestionnaireResponse = "QuestionnaireResponse",
+    Coverage = "Coverage",
+    Procedure = "Procedure",
+    AuditEvent = "AuditEvent",
+    PaymentReconciliation = "PaymentReconciliation",
+    MedicinalProductManufactured = "MedicinalProductManufactured",
+    CompartmentDefinition = "CompartmentDefinition",
+    Organization = "Organization",
+    ExplanationOfBenefit = "ExplanationOfBenefit",
+    Composition = "Composition",
+    CoverageEligibilityResponse = "CoverageEligibilityResponse",
+    DocumentReference = "DocumentReference",
+    EventDefinition = "EventDefinition",
+    SubstanceProtein = "SubstanceProtein",
+    TerminologyCapabilities = "TerminologyCapabilities",
+    Encounter = "Encounter",
+    ImplementationGuide = "ImplementationGuide",
+    EvidenceVariable = "EvidenceVariable",
+    ObservationDefinition = "ObservationDefinition",
+    DiagnosticReport = "DiagnosticReport",
+    ExampleScenario = "ExampleScenario",
+    ResearchDefinition = "ResearchDefinition",
+    Parameters = "Parameters",
+    SearchParameter = "SearchParameter",
+    MedicinalProductInteraction = "MedicinalProductInteraction",
+    CodeSystem = "CodeSystem",
+    MessageDefinition = "MessageDefinition",
+    NutritionOrder = "NutritionOrder",
+    VerificationResult = "VerificationResult",
+    MedicationAdministration = "MedicationAdministration",
+    CatalogEntry = "CatalogEntry",
+    Flag = "Flag",
+    DeviceUseStatement = "DeviceUseStatement",
+    Contract = "Contract",
+    Invoice = "Invoice",
+    PaymentNotice = "PaymentNotice",
+    Location = "Location",
+    Claim = "Claim",
+    Specimen = "Specimen",
+    MedicationStatement = "MedicationStatement",
+    EnrollmentResponse = "EnrollmentResponse",
+    Evidence = "Evidence",
+    Bundle = "Bundle",
+    ResearchElementDefinition = "ResearchElementDefinition",
+    BodyStructure = "BodyStructure",
+    MedicinalProduct = "MedicinalProduct",
+    ResearchStudy = "ResearchStudy",
+    AppointmentResponse = "AppointmentResponse",
+    MedicinalProductIndication = "MedicinalProductIndication",
+    Measure = "Measure",
+    Person = "Person",
+    InsurancePlan = "InsurancePlan",
+    Patient = "Patient",
+    EffectEvidenceSynthesis = "EffectEvidenceSynthesis",
+    ResearchSubject = "ResearchSubject",
+    Medication = "Medication",
+    ConceptMap = "ConceptMap",
+    CoverageEligibilityRequest = "CoverageEligibilityRequest",
+    SubstanceSourceMaterial = "SubstanceSourceMaterial",
+    VisionPrescription = "VisionPrescription",
+    MolecularSequence = "MolecularSequence",
+    MedicinalProductUndesirableEffect = "MedicinalProductUndesirableEffect",
+    OperationOutcome = "OperationOutcome",
+    MessageHeader = "MessageHeader",
+    AllergyIntolerance = "AllergyIntolerance",
+    SubstanceReferenceInformation = "SubstanceReferenceInformation",
+    SupplyDelivery = "SupplyDelivery",
+    EpisodeOfCare = "EpisodeOfCare",
+    PractitionerRole = "PractitionerRole",
+    Library = "Library",
+    Practitioner = "Practitioner",
+    MedicationRequest = "MedicationRequest",
+    ImmunizationRecommendation = "ImmunizationRecommendation",
+    Immunization = "Immunization",
+    GraphDefinition = "GraphDefinition",
+    Account = "Account",
+    MedicinalProductIngredient = "MedicinalProductIngredient",
+    MeasureReport = "MeasureReport",
+    DeviceMetric = "DeviceMetric",
+    Goal = "Goal",
+    MedicationKnowledge = "MedicationKnowledge",
+    ClaimResponse = "ClaimResponse",
+    DeviceDefinition = "DeviceDefinition",
+    Slot = "Slot",
+    ValueSet = "ValueSet",
+    MedicinalProductAuthorization = "MedicinalProductAuthorization",
+    StructureDefinition = "StructureDefinition",
+    MedicinalProductContraindication = "MedicinalProductContraindication",
+    DeviceRequest = "DeviceRequest",
+    List = "List",
+    Questionnaire = "Questionnaire",
+    DomainResource = "DomainResource",
+    Endpoint = "Endpoint",
+    NamingSystem = "NamingSystem",
+    MedicinalProductPackaged = "MedicinalProductPackaged",
+    Basic = "Basic",
+    Binary = "Binary",
+    PlanDefinition = "PlanDefinition",
+    Subscription = "Subscription",
+    RelatedPerson = "RelatedPerson",
+    SubstanceSpecification = "SubstanceSpecification",
+    SubstanceNucleicAcid = "SubstanceNucleicAcid",
+    GuidanceResponse = "GuidanceResponse",
+    ClinicalImpression = "ClinicalImpression",
+    OrganizationAffiliation = "OrganizationAffiliation",
+    Resource = "Resource",
+    Condition = "Condition",
+    CapabilityStatement = "CapabilityStatement",
+    HealthcareService = "HealthcareService",
+    SpecimenDefinition = "SpecimenDefinition",
+    RiskAssessment = "RiskAssessment",
+    OperationDefinition = "OperationDefinition",
+    ActivityDefinition = "ActivityDefinition",
+    Schedule = "Schedule",
+    BiologicallyDerivedProduct = "BiologicallyDerivedProduct",
+    Group = "Group",
+    MedicinalProductPharmaceutical = "MedicinalProductPharmaceutical",
+    FamilyMemberHistory = "FamilyMemberHistory",
+    ServiceRequest = "ServiceRequest",
+    DetectedIssue = "DetectedIssue",
+    Device = "Device",
+    RequestGroup = "RequestGroup",
+    TestScript = "TestScript",
+    RiskEvidenceSynthesis = "RiskEvidenceSynthesis",
+    SupplyRequest = "SupplyRequest",
+    Task = "Task",
+    CommunicationRequest = "CommunicationRequest",
+    EnrollmentRequest = "EnrollmentRequest",
+    ChargeItemDefinition = "ChargeItemDefinition",
+    Substance = "Substance",
+    Provenance = "Provenance",
+    Consent = "Consent",
+    CarePlan = "CarePlan",
+    TestReport = "TestReport",
+    Observation = "Observation",
+    DocumentManifest = "DocumentManifest"
+}
 /** If messaging is supported */
 export interface CapabilityStatementMessaging extends BackboneElement {
     /** Where messages should be sent */
@@ -223,7 +448,7 @@ export interface CapabilityStatementResource extends BackboneElement {
     _updateCreate?: Element;
     _conditionalCreate?: Element;
     /** not-supported | modified-since | not-match | full-support */
-    conditionalRead?: code;
+    conditionalRead?: `${CapabilityStatementConditionalRead}`;
     _type?: Element;
     operation?: Array<CapabilityStatementRestResourceOperation>;
     _conditionalUpdate?: Element;
@@ -232,7 +457,7 @@ export interface CapabilityStatementResource extends BackboneElement {
     /** Whether vRead can return past versions */
     readHistory?: boolean;
     /** A resource type that is supported */
-    type: code;
+    type: `${CapabilityStatementType}`;
     /** What operations are supported? */
     interaction?: Array<CapabilityStatementInteraction>;
     _conditionalRead?: Element;
@@ -251,13 +476,26 @@ export interface CapabilityStatementResource extends BackboneElement {
     /** _include values supported by the server */
     searchInclude?: Array<string>;
     /** no-version | versioned | versioned-update */
-    versioning?: code;
+    versioning?: `${CapabilityStatementVersioning}`;
     /** Base System profile for all uses of resource */
     profile?: canonical;
     _versioning?: Element;
     _supportedProfile?: Array<Element>;
     /** not-supported | single | multiple - how conditional delete is supported */
-    conditionalDelete?: code;
+    conditionalDelete?: `${CapabilityStatementConditionalDelete}`;
+}
+/** draft | active | retired | unknown */
+export declare enum CapabilityStatementStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** instance | capability | requirements */
+export declare enum CapabilityStatementKind {
+    Capability = "capability",
+    Instance = "instance",
+    Requirements = "requirements"
 }
 /** Software that is covered by this capability statement */
 export interface CapabilityStatementSoftware extends BackboneElement {
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CapabilityStatement.js b/vendor/r4/types/hl7-fhir-r4-core/CapabilityStatement.js
index c8ad2e5..397a749 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CapabilityStatement.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/CapabilityStatement.js
@@ -1,2 +1,250 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityStatementKind = exports.CapabilityStatementStatus = exports.CapabilityStatementType = exports.CapabilityStatementFhirVersion = exports.CapabilityStatementMode = exports.CapabilityStatementRestResourceSearchParamType = exports.CapabilityStatementCode = exports.CapabilityStatementConditionalRead = exports.CapabilityStatementVersioning = exports.CapabilityStatementConditionalDelete = void 0;
+/** not-supported | single | multiple - how conditional delete is supported */
+var CapabilityStatementConditionalDelete;
+(function (CapabilityStatementConditionalDelete) {
+    CapabilityStatementConditionalDelete["Multiple"] = "multiple";
+    CapabilityStatementConditionalDelete["NotSupported"] = "not-supported";
+    CapabilityStatementConditionalDelete["Single"] = "single";
+})(CapabilityStatementConditionalDelete = exports.CapabilityStatementConditionalDelete || (exports.CapabilityStatementConditionalDelete = {}));
+/** no-version | versioned | versioned-update */
+var CapabilityStatementVersioning;
+(function (CapabilityStatementVersioning) {
+    CapabilityStatementVersioning["NoVersion"] = "no-version";
+    CapabilityStatementVersioning["Versioned"] = "versioned";
+    CapabilityStatementVersioning["VersionedUpdate"] = "versioned-update";
+})(CapabilityStatementVersioning = exports.CapabilityStatementVersioning || (exports.CapabilityStatementVersioning = {}));
+/** not-supported | modified-since | not-match | full-support */
+var CapabilityStatementConditionalRead;
+(function (CapabilityStatementConditionalRead) {
+    CapabilityStatementConditionalRead["FullSupport"] = "full-support";
+    CapabilityStatementConditionalRead["ModifiedSince"] = "modified-since";
+    CapabilityStatementConditionalRead["NotMatch"] = "not-match";
+    CapabilityStatementConditionalRead["NotSupported"] = "not-supported";
+})(CapabilityStatementConditionalRead = exports.CapabilityStatementConditionalRead || (exports.CapabilityStatementConditionalRead = {}));
+/** read | vread | update | patch | delete | history-instance | history-type | create | search-type */
+var CapabilityStatementCode;
+(function (CapabilityStatementCode) {
+    CapabilityStatementCode["SearchType"] = "search-type";
+    CapabilityStatementCode["HistoryType"] = "history-type";
+    CapabilityStatementCode["Delete"] = "delete";
+    CapabilityStatementCode["Update"] = "update";
+    CapabilityStatementCode["Read"] = "read";
+    CapabilityStatementCode["Create"] = "create";
+    CapabilityStatementCode["Vread"] = "vread";
+    CapabilityStatementCode["HistoryInstance"] = "history-instance";
+    CapabilityStatementCode["Patch"] = "patch";
+})(CapabilityStatementCode = exports.CapabilityStatementCode || (exports.CapabilityStatementCode = {}));
+/** number | date | string | token | reference | composite | quantity | uri | special */
+var CapabilityStatementRestResourceSearchParamType;
+(function (CapabilityStatementRestResourceSearchParamType) {
+    CapabilityStatementRestResourceSearchParamType["Uri"] = "uri";
+    CapabilityStatementRestResourceSearchParamType["Number"] = "number";
+    CapabilityStatementRestResourceSearchParamType["Date"] = "date";
+    CapabilityStatementRestResourceSearchParamType["Special"] = "special";
+    CapabilityStatementRestResourceSearchParamType["Quantity"] = "quantity";
+    CapabilityStatementRestResourceSearchParamType["String"] = "string";
+    CapabilityStatementRestResourceSearchParamType["Composite"] = "composite";
+    CapabilityStatementRestResourceSearchParamType["Token"] = "token";
+    CapabilityStatementRestResourceSearchParamType["Reference"] = "reference";
+})(CapabilityStatementRestResourceSearchParamType = exports.CapabilityStatementRestResourceSearchParamType || (exports.CapabilityStatementRestResourceSearchParamType = {}));
+/** client | server */
+var CapabilityStatementMode;
+(function (CapabilityStatementMode) {
+    CapabilityStatementMode["Client"] = "client";
+    CapabilityStatementMode["Server"] = "server";
+})(CapabilityStatementMode = exports.CapabilityStatementMode || (exports.CapabilityStatementMode = {}));
+/** FHIR Version the system supports */
+var CapabilityStatementFhirVersion;
+(function (CapabilityStatementFhirVersion) {
+    CapabilityStatementFhirVersion["Num1.8.0"] = "1.8.0";
+    CapabilityStatementFhirVersion["Num0.05"] = "0.05";
+    CapabilityStatementFhirVersion["Num0.01"] = "0.01";
+    CapabilityStatementFhirVersion["Num3.0.1"] = "3.0.1";
+    CapabilityStatementFhirVersion["Num1.0.0"] = "1.0.0";
+    CapabilityStatementFhirVersion["Num3.3.0"] = "3.3.0";
+    CapabilityStatementFhirVersion["Num0.0.82"] = "0.0.82";
+    CapabilityStatementFhirVersion["Num1.6.0"] = "1.6.0";
+    CapabilityStatementFhirVersion["Num1.4.0"] = "1.4.0";
+    CapabilityStatementFhirVersion["Num3.0.0"] = "3.0.0";
+    CapabilityStatementFhirVersion["Num0.0.80"] = "0.0.80";
+    CapabilityStatementFhirVersion["Num4.0.0"] = "4.0.0";
+    CapabilityStatementFhirVersion["Num0.11"] = "0.11";
+    CapabilityStatementFhirVersion["Num0.06"] = "0.06";
+    CapabilityStatementFhirVersion["Num1.0.2"] = "1.0.2";
+    CapabilityStatementFhirVersion["Num1.0.1"] = "1.0.1";
+    CapabilityStatementFhirVersion["Num0.4.0"] = "0.4.0";
+    CapabilityStatementFhirVersion["Num4.0.1"] = "4.0.1";
+    CapabilityStatementFhirVersion["Num3.5.0"] = "3.5.0";
+    CapabilityStatementFhirVersion["Num0.5.0"] = "0.5.0";
+    CapabilityStatementFhirVersion["Num1.1.0"] = "1.1.0";
+    CapabilityStatementFhirVersion["Num0.0.81"] = "0.0.81";
+})(CapabilityStatementFhirVersion = exports.CapabilityStatementFhirVersion || (exports.CapabilityStatementFhirVersion = {}));
+/** A resource type that is supported */
+var CapabilityStatementType;
+(function (CapabilityStatementType) {
+    CapabilityStatementType["ImmunizationEvaluation"] = "ImmunizationEvaluation";
+    CapabilityStatementType["Appointment"] = "Appointment";
+    CapabilityStatementType["StructureMap"] = "StructureMap";
+    CapabilityStatementType["CareTeam"] = "CareTeam";
+    CapabilityStatementType["Linkage"] = "Linkage";
+    CapabilityStatementType["Communication"] = "Communication";
+    CapabilityStatementType["MedicationDispense"] = "MedicationDispense";
+    CapabilityStatementType["ImagingStudy"] = "ImagingStudy";
+    CapabilityStatementType["ChargeItem"] = "ChargeItem";
+    CapabilityStatementType["AdverseEvent"] = "AdverseEvent";
+    CapabilityStatementType["Media"] = "Media";
+    CapabilityStatementType["SubstancePolymer"] = "SubstancePolymer";
+    CapabilityStatementType["QuestionnaireResponse"] = "QuestionnaireResponse";
+    CapabilityStatementType["Coverage"] = "Coverage";
+    CapabilityStatementType["Procedure"] = "Procedure";
+    CapabilityStatementType["AuditEvent"] = "AuditEvent";
+    CapabilityStatementType["PaymentReconciliation"] = "PaymentReconciliation";
+    CapabilityStatementType["MedicinalProductManufactured"] = "MedicinalProductManufactured";
+    CapabilityStatementType["CompartmentDefinition"] = "CompartmentDefinition";
+    CapabilityStatementType["Organization"] = "Organization";
+    CapabilityStatementType["ExplanationOfBenefit"] = "ExplanationOfBenefit";
+    CapabilityStatementType["Composition"] = "Composition";
+    CapabilityStatementType["CoverageEligibilityResponse"] = "CoverageEligibilityResponse";
+    CapabilityStatementType["DocumentReference"] = "DocumentReference";
+    CapabilityStatementType["EventDefinition"] = "EventDefinition";
+    CapabilityStatementType["SubstanceProtein"] = "SubstanceProtein";
+    CapabilityStatementType["TerminologyCapabilities"] = "TerminologyCapabilities";
+    CapabilityStatementType["Encounter"] = "Encounter";
+    CapabilityStatementType["ImplementationGuide"] = "ImplementationGuide";
+    CapabilityStatementType["EvidenceVariable"] = "EvidenceVariable";
+    CapabilityStatementType["ObservationDefinition"] = "ObservationDefinition";
+    CapabilityStatementType["DiagnosticReport"] = "DiagnosticReport";
+    CapabilityStatementType["ExampleScenario"] = "ExampleScenario";
+    CapabilityStatementType["ResearchDefinition"] = "ResearchDefinition";
+    CapabilityStatementType["Parameters"] = "Parameters";
+    CapabilityStatementType["SearchParameter"] = "SearchParameter";
+    CapabilityStatementType["MedicinalProductInteraction"] = "MedicinalProductInteraction";
+    CapabilityStatementType["CodeSystem"] = "CodeSystem";
+    CapabilityStatementType["MessageDefinition"] = "MessageDefinition";
+    CapabilityStatementType["NutritionOrder"] = "NutritionOrder";
+    CapabilityStatementType["VerificationResult"] = "VerificationResult";
+    CapabilityStatementType["MedicationAdministration"] = "MedicationAdministration";
+    CapabilityStatementType["CatalogEntry"] = "CatalogEntry";
+    CapabilityStatementType["Flag"] = "Flag";
+    CapabilityStatementType["DeviceUseStatement"] = "DeviceUseStatement";
+    CapabilityStatementType["Contract"] = "Contract";
+    CapabilityStatementType["Invoice"] = "Invoice";
+    CapabilityStatementType["PaymentNotice"] = "PaymentNotice";
+    CapabilityStatementType["Location"] = "Location";
+    CapabilityStatementType["Claim"] = "Claim";
+    CapabilityStatementType["Specimen"] = "Specimen";
+    CapabilityStatementType["MedicationStatement"] = "MedicationStatement";
+    CapabilityStatementType["EnrollmentResponse"] = "EnrollmentResponse";
+    CapabilityStatementType["Evidence"] = "Evidence";
+    CapabilityStatementType["Bundle"] = "Bundle";
+    CapabilityStatementType["ResearchElementDefinition"] = "ResearchElementDefinition";
+    CapabilityStatementType["BodyStructure"] = "BodyStructure";
+    CapabilityStatementType["MedicinalProduct"] = "MedicinalProduct";
+    CapabilityStatementType["ResearchStudy"] = "ResearchStudy";
+    CapabilityStatementType["AppointmentResponse"] = "AppointmentResponse";
+    CapabilityStatementType["MedicinalProductIndication"] = "MedicinalProductIndication";
+    CapabilityStatementType["Measure"] = "Measure";
+    CapabilityStatementType["Person"] = "Person";
+    CapabilityStatementType["InsurancePlan"] = "InsurancePlan";
+    CapabilityStatementType["Patient"] = "Patient";
+    CapabilityStatementType["EffectEvidenceSynthesis"] = "EffectEvidenceSynthesis";
+    CapabilityStatementType["ResearchSubject"] = "ResearchSubject";
+    CapabilityStatementType["Medication"] = "Medication";
+    CapabilityStatementType["ConceptMap"] = "ConceptMap";
+    CapabilityStatementType["CoverageEligibilityRequest"] = "CoverageEligibilityRequest";
+    CapabilityStatementType["SubstanceSourceMaterial"] = "SubstanceSourceMaterial";
+    CapabilityStatementType["VisionPrescription"] = "VisionPrescription";
+    CapabilityStatementType["MolecularSequence"] = "MolecularSequence";
+    CapabilityStatementType["MedicinalProductUndesirableEffect"] = "MedicinalProductUndesirableEffect";
+    CapabilityStatementType["OperationOutcome"] = "OperationOutcome";
+    CapabilityStatementType["MessageHeader"] = "MessageHeader";
+    CapabilityStatementType["AllergyIntolerance"] = "AllergyIntolerance";
+    CapabilityStatementType["SubstanceReferenceInformation"] = "SubstanceReferenceInformation";
+    CapabilityStatementType["SupplyDelivery"] = "SupplyDelivery";
+    CapabilityStatementType["EpisodeOfCare"] = "EpisodeOfCare";
+    CapabilityStatementType["PractitionerRole"] = "PractitionerRole";
+    CapabilityStatementType["Library"] = "Library";
+    CapabilityStatementType["Practitioner"] = "Practitioner";
+    CapabilityStatementType["MedicationRequest"] = "MedicationRequest";
+    CapabilityStatementType["ImmunizationRecommendation"] = "ImmunizationRecommendation";
+    CapabilityStatementType["Immunization"] = "Immunization";
+    CapabilityStatementType["GraphDefinition"] = "GraphDefinition";
+    CapabilityStatementType["Account"] = "Account";
+    CapabilityStatementType["MedicinalProductIngredient"] = "MedicinalProductIngredient";
+    CapabilityStatementType["MeasureReport"] = "MeasureReport";
+    CapabilityStatementType["DeviceMetric"] = "DeviceMetric";
+    CapabilityStatementType["Goal"] = "Goal";
+    CapabilityStatementType["MedicationKnowledge"] = "MedicationKnowledge";
+    CapabilityStatementType["ClaimResponse"] = "ClaimResponse";
+    CapabilityStatementType["DeviceDefinition"] = "DeviceDefinition";
+    CapabilityStatementType["Slot"] = "Slot";
+    CapabilityStatementType["ValueSet"] = "ValueSet";
+    CapabilityStatementType["MedicinalProductAuthorization"] = "MedicinalProductAuthorization";
+    CapabilityStatementType["StructureDefinition"] = "StructureDefinition";
+    CapabilityStatementType["MedicinalProductContraindication"] = "MedicinalProductContraindication";
+    CapabilityStatementType["DeviceRequest"] = "DeviceRequest";
+    CapabilityStatementType["List"] = "List";
+    CapabilityStatementType["Questionnaire"] = "Questionnaire";
+    CapabilityStatementType["DomainResource"] = "DomainResource";
+    CapabilityStatementType["Endpoint"] = "Endpoint";
+    CapabilityStatementType["NamingSystem"] = "NamingSystem";
+    CapabilityStatementType["MedicinalProductPackaged"] = "MedicinalProductPackaged";
+    CapabilityStatementType["Basic"] = "Basic";
+    CapabilityStatementType["Binary"] = "Binary";
+    CapabilityStatementType["PlanDefinition"] = "PlanDefinition";
+    CapabilityStatementType["Subscription"] = "Subscription";
+    CapabilityStatementType["RelatedPerson"] = "RelatedPerson";
+    CapabilityStatementType["SubstanceSpecification"] = "SubstanceSpecification";
+    CapabilityStatementType["SubstanceNucleicAcid"] = "SubstanceNucleicAcid";
+    CapabilityStatementType["GuidanceResponse"] = "GuidanceResponse";
+    CapabilityStatementType["ClinicalImpression"] = "ClinicalImpression";
+    CapabilityStatementType["OrganizationAffiliation"] = "OrganizationAffiliation";
+    CapabilityStatementType["Resource"] = "Resource";
+    CapabilityStatementType["Condition"] = "Condition";
+    CapabilityStatementType["CapabilityStatement"] = "CapabilityStatement";
+    CapabilityStatementType["HealthcareService"] = "HealthcareService";
+    CapabilityStatementType["SpecimenDefinition"] = "SpecimenDefinition";
+    CapabilityStatementType["RiskAssessment"] = "RiskAssessment";
+    CapabilityStatementType["OperationDefinition"] = "OperationDefinition";
+    CapabilityStatementType["ActivityDefinition"] = "ActivityDefinition";
+    CapabilityStatementType["Schedule"] = "Schedule";
+    CapabilityStatementType["BiologicallyDerivedProduct"] = "BiologicallyDerivedProduct";
+    CapabilityStatementType["Group"] = "Group";
+    CapabilityStatementType["MedicinalProductPharmaceutical"] = "MedicinalProductPharmaceutical";
+    CapabilityStatementType["FamilyMemberHistory"] = "FamilyMemberHistory";
+    CapabilityStatementType["ServiceRequest"] = "ServiceRequest";
+    CapabilityStatementType["DetectedIssue"] = "DetectedIssue";
+    CapabilityStatementType["Device"] = "Device";
+    CapabilityStatementType["RequestGroup"] = "RequestGroup";
+    CapabilityStatementType["TestScript"] = "TestScript";
+    CapabilityStatementType["RiskEvidenceSynthesis"] = "RiskEvidenceSynthesis";
+    CapabilityStatementType["SupplyRequest"] = "SupplyRequest";
+    CapabilityStatementType["Task"] = "Task";
+    CapabilityStatementType["CommunicationRequest"] = "CommunicationRequest";
+    CapabilityStatementType["EnrollmentRequest"] = "EnrollmentRequest";
+    CapabilityStatementType["ChargeItemDefinition"] = "ChargeItemDefinition";
+    CapabilityStatementType["Substance"] = "Substance";
+    CapabilityStatementType["Provenance"] = "Provenance";
+    CapabilityStatementType["Consent"] = "Consent";
+    CapabilityStatementType["CarePlan"] = "CarePlan";
+    CapabilityStatementType["TestReport"] = "TestReport";
+    CapabilityStatementType["Observation"] = "Observation";
+    CapabilityStatementType["DocumentManifest"] = "DocumentManifest";
+})(CapabilityStatementType = exports.CapabilityStatementType || (exports.CapabilityStatementType = {}));
+/** draft | active | retired | unknown */
+var CapabilityStatementStatus;
+(function (CapabilityStatementStatus) {
+    CapabilityStatementStatus["Active"] = "active";
+    CapabilityStatementStatus["Draft"] = "draft";
+    CapabilityStatementStatus["Retired"] = "retired";
+    CapabilityStatementStatus["Unknown"] = "unknown";
+})(CapabilityStatementStatus = exports.CapabilityStatementStatus || (exports.CapabilityStatementStatus = {}));
+/** instance | capability | requirements */
+var CapabilityStatementKind;
+(function (CapabilityStatementKind) {
+    CapabilityStatementKind["Capability"] = "capability";
+    CapabilityStatementKind["Instance"] = "instance";
+    CapabilityStatementKind["Requirements"] = "requirements";
+})(CapabilityStatementKind = exports.CapabilityStatementKind || (exports.CapabilityStatementKind = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CarePlan.d.ts b/vendor/r4/types/hl7-fhir-r4-core/CarePlan.d.ts
index 2ad4375..8f2c683 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CarePlan.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/CarePlan.d.ts
@@ -11,11 +11,11 @@ import { canonical } from "./canonical";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Describes the intention of how one or more practitioners intend to deliver care for a particular patient, group or community for a period of time, possibly limited to care for a specific condition or set of conditions. */
 export interface CarePlan extends DomainResource {
+    resourceType: 'CarePlan';
     _created?: Element;
     /** Summary of nature of plan */
     description?: string;
@@ -30,7 +30,7 @@ export interface CarePlan extends DomainResource {
     /** Information considered as part of plan */
     supportingInfo?: Array<Reference>;
     /** Encounter created as part of */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _status?: Element;
     /** Desired outcome of plan */
     goal?: Array<Reference>;
@@ -42,18 +42,18 @@ export interface CarePlan extends DomainResource {
     /** Comments about the plan */
     note?: Array<Annotation>;
     /** Who is the designated responsible party */
-    author?: Reference<"CareTeam" | "Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    author?: Reference<'CareTeam' | 'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     _intent?: Element;
     /** Action to occur as part of plan */
     activity?: Array<CarePlanActivity>;
     /** Who provided the content of the care plan */
     contributor?: Array<Reference>;
     /** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
-    status: code;
+    status: `${CarePlanStatus}`;
     /** External Ids for this plan */
     identifier?: Array<Identifier>;
     /** proposal | plan | order | option */
-    intent: code;
+    intent: `${CarePlanIntent}`;
     _title?: Element;
     /** CarePlan replaced by this CarePlan */
     replaces?: Array<Reference>;
@@ -65,11 +65,32 @@ export interface CarePlan extends DomainResource {
     partOf?: Array<Reference>;
     _instantiatesCanonical?: Array<Element>;
     /** Who the care plan is for */
-    subject: Reference<"Patient" | "Group">;
+    subject: Reference<'Patient' | 'Group'>;
     /** Who's involved in plan? */
     careTeam?: Array<Reference>;
     _instantiatesUri?: Array<Element>;
 }
+/** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
+export declare enum CarePlanStatus {
+    Active = "active",
+    Completed = "completed",
+    Draft = "draft",
+    EnteredInError = "entered-in-error",
+    OnHold = "on-hold",
+    Revoked = "revoked",
+    Unknown = "unknown"
+}
+/** Appointment | CommunicationRequest | DeviceRequest | MedicationRequest | NutritionOrder | Task | ServiceRequest | VisionPrescription */
+export declare enum CarePlanKind {
+    Appointment = "Appointment",
+    NutritionOrder = "NutritionOrder",
+    VisionPrescription = "VisionPrescription",
+    MedicationRequest = "MedicationRequest",
+    DeviceRequest = "DeviceRequest",
+    ServiceRequest = "ServiceRequest",
+    Task = "Task",
+    CommunicationRequest = "CommunicationRequest"
+}
 /** In-line definition of activity */
 export interface CarePlanDetail extends BackboneElement {
     /** Extra info describing activity to perform */
@@ -81,7 +102,7 @@ export interface CarePlanDetail extends BackboneElement {
     instantiatesUri?: Array<uri>;
     _doNotPerform?: Element;
     productCodeableConcept?: CodeableConcept;
-    productReference?: Reference<"Medication" | "Substance">;
+    productReference?: Reference<'Medication' | 'Substance'>;
     scheduledPeriod?: Period;
     _status?: Element;
     /** Goals this activity relates to */
@@ -97,9 +118,9 @@ export interface CarePlanDetail extends BackboneElement {
     _description?: Element;
     scheduledString?: string;
     /** not-started | scheduled | in-progress | on-hold | completed | cancelled | stopped | unknown | entered-in-error */
-    status: code;
+    status: `${CarePlanStatus}`;
     /** Appointment | CommunicationRequest | DeviceRequest | MedicationRequest | NutritionOrder | Task | ServiceRequest | VisionPrescription */
-    kind?: code;
+    kind?: `${CarePlanKind}`;
     /** Detail type of activity */
     code?: CodeableConcept;
     /** If true, activity is prohibiting action */
@@ -107,7 +128,7 @@ export interface CarePlanDetail extends BackboneElement {
     /** How much to administer/supply/consume */
     quantity?: SimpleQuantity;
     /** Where it should happen */
-    location?: Reference<"Location">;
+    location?: Reference<'Location'>;
     _instantiatesCanonical?: Array<Element>;
     /** Who will be responsible? */
     performer?: Array<Reference>;
@@ -124,7 +145,14 @@ export interface CarePlanActivity extends BackboneElement {
     /** Comments about the activity status/progress */
     progress?: Array<Annotation>;
     /** Activity details defined in specific resource */
-    reference?: Reference<"RequestGroup" | "NutritionOrder" | "ServiceRequest" | "CommunicationRequest" | "VisionPrescription" | "DeviceRequest" | "Task" | "MedicationRequest" | "Appointment">;
+    reference?: Reference<'RequestGroup' | 'NutritionOrder' | 'ServiceRequest' | 'CommunicationRequest' | 'VisionPrescription' | 'DeviceRequest' | 'Task' | 'MedicationRequest' | 'Appointment'>;
     /** In-line definition of activity */
     detail?: CarePlanDetail;
 }
+/** proposal | plan | order | option */
+export declare enum CarePlanIntent {
+    Option = "option",
+    Order = "order",
+    Proposal = "proposal",
+    Plan = "plan"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CarePlan.js b/vendor/r4/types/hl7-fhir-r4-core/CarePlan.js
index c8ad2e5..ff07c08 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CarePlan.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/CarePlan.js
@@ -1,2 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarePlanIntent = exports.CarePlanKind = exports.CarePlanStatus = void 0;
+/** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
+var CarePlanStatus;
+(function (CarePlanStatus) {
+    CarePlanStatus["Active"] = "active";
+    CarePlanStatus["Completed"] = "completed";
+    CarePlanStatus["Draft"] = "draft";
+    CarePlanStatus["EnteredInError"] = "entered-in-error";
+    CarePlanStatus["OnHold"] = "on-hold";
+    CarePlanStatus["Revoked"] = "revoked";
+    CarePlanStatus["Unknown"] = "unknown";
+})(CarePlanStatus = exports.CarePlanStatus || (exports.CarePlanStatus = {}));
+/** Appointment | CommunicationRequest | DeviceRequest | MedicationRequest | NutritionOrder | Task | ServiceRequest | VisionPrescription */
+var CarePlanKind;
+(function (CarePlanKind) {
+    CarePlanKind["Appointment"] = "Appointment";
+    CarePlanKind["NutritionOrder"] = "NutritionOrder";
+    CarePlanKind["VisionPrescription"] = "VisionPrescription";
+    CarePlanKind["MedicationRequest"] = "MedicationRequest";
+    CarePlanKind["DeviceRequest"] = "DeviceRequest";
+    CarePlanKind["ServiceRequest"] = "ServiceRequest";
+    CarePlanKind["Task"] = "Task";
+    CarePlanKind["CommunicationRequest"] = "CommunicationRequest";
+})(CarePlanKind = exports.CarePlanKind || (exports.CarePlanKind = {}));
+/** proposal | plan | order | option */
+var CarePlanIntent;
+(function (CarePlanIntent) {
+    CarePlanIntent["Option"] = "option";
+    CarePlanIntent["Order"] = "order";
+    CarePlanIntent["Proposal"] = "proposal";
+    CarePlanIntent["Plan"] = "plan";
+})(CarePlanIntent = exports.CarePlanIntent || (exports.CarePlanIntent = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CareTeam.d.ts b/vendor/r4/types/hl7-fhir-r4-core/CareTeam.d.ts
index 46ccf3a..38d5dee 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CareTeam.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/CareTeam.d.ts
@@ -7,17 +7,17 @@ import { ContactPoint } from "./ContactPoint";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care for a patient. */
 export interface CareTeam extends DomainResource {
+    resourceType: 'CareTeam';
     /** Type of team */
     category?: Array<CodeableConcept>;
     /** Organization responsible for the care team */
     managingOrganization?: Array<Reference>;
     /** Encounter created as part of */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     /** Name of the team, such as crisis assessment team */
     name?: string;
     _status?: Element;
@@ -28,7 +28,7 @@ export interface CareTeam extends DomainResource {
     /** Comments made about the CareTeam */
     note?: Array<Annotation>;
     /** proposed | active | suspended | inactive | entered-in-error */
-    status?: code;
+    status?: `${CareTeamStatus}`;
     _name?: Element;
     /** External Ids for this team */
     identifier?: Array<Identifier>;
@@ -37,7 +37,7 @@ export interface CareTeam extends DomainResource {
     /** Time period team covers */
     period?: Period;
     /** Who care team is for */
-    subject?: Reference<"Patient" | "Group">;
+    subject?: Reference<'Patient' | 'Group'>;
     /** Why the care team exists */
     reasonReference?: Array<Reference>;
 }
@@ -46,9 +46,17 @@ export interface CareTeamParticipant extends BackboneElement {
     /** Type of involvement */
     role?: Array<CodeableConcept>;
     /** Who is involved */
-    member?: Reference<"CareTeam" | "Patient" | "PractitionerRole" | "Organization" | "Practitioner" | "RelatedPerson">;
+    member?: Reference<'CareTeam' | 'Patient' | 'PractitionerRole' | 'Organization' | 'Practitioner' | 'RelatedPerson'>;
     /** Organization of the practitioner */
-    onBehalfOf?: Reference<"Organization">;
+    onBehalfOf?: Reference<'Organization'>;
     /** Time period of participant */
     period?: Period;
 }
+/** proposed | active | suspended | inactive | entered-in-error */
+export declare enum CareTeamStatus {
+    Active = "active",
+    EnteredInError = "entered-in-error",
+    Inactive = "inactive",
+    Proposed = "proposed",
+    Suspended = "suspended"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CareTeam.js b/vendor/r4/types/hl7-fhir-r4-core/CareTeam.js
index c8ad2e5..ba2a26e 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CareTeam.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/CareTeam.js
@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CareTeamStatus = void 0;
+/** proposed | active | suspended | inactive | entered-in-error */
+var CareTeamStatus;
+(function (CareTeamStatus) {
+    CareTeamStatus["Active"] = "active";
+    CareTeamStatus["EnteredInError"] = "entered-in-error";
+    CareTeamStatus["Inactive"] = "inactive";
+    CareTeamStatus["Proposed"] = "proposed";
+    CareTeamStatus["Suspended"] = "suspended";
+})(CareTeamStatus = exports.CareTeamStatus || (exports.CareTeamStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CatalogEntry.d.ts b/vendor/r4/types/hl7-fhir-r4-core/CatalogEntry.d.ts
index 8b44271..1bf0f58 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CatalogEntry.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/CatalogEntry.d.ts
@@ -6,17 +6,17 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Catalog entries are wrappers that contextualize items included in a catalog. */
 export interface CatalogEntry extends DomainResource {
+    resourceType: 'CatalogEntry';
     /** Additional characteristics of the catalog entry */
     additionalCharacteristic?: Array<CodeableConcept>;
     /** Additional classification of the catalog entry */
     additionalClassification?: Array<CodeableConcept>;
     /** The item that is being defined */
-    referencedItem: Reference<"PractitionerRole" | "HealthcareService" | "Medication" | "Organization" | "Device" | "Practitioner" | "PlanDefinition" | "SpecimenDefinition" | "ActivityDefinition" | "Binary" | "ObservationDefinition">;
+    referencedItem: Reference<'PractitionerRole' | 'HealthcareService' | 'Medication' | 'Organization' | 'Device' | 'Practitioner' | 'PlanDefinition' | 'SpecimenDefinition' | 'ActivityDefinition' | 'Binary' | 'ObservationDefinition'>;
     _validTo?: Element;
     _status?: Element;
     /** The type of item - medication, device, service, protocol or other */
@@ -28,7 +28,7 @@ export interface CatalogEntry extends DomainResource {
     /** Whether the entry represents an orderable item */
     orderable: boolean;
     /** draft | active | retired | unknown */
-    status?: code;
+    status?: `${CatalogEntryStatus}`;
     /** The date until which this catalog entry is expected to be active */
     validTo?: dateTime;
     /** Unique identifier of the catalog item */
@@ -42,11 +42,23 @@ export interface CatalogEntry extends DomainResource {
     /** An item that this catalog entry is related to */
     relatedEntry?: Array<CatalogEntryRelatedEntry>;
 }
+/** draft | active | retired | unknown */
+export declare enum CatalogEntryStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** triggers | is-replaced-by */
+export declare enum CatalogEntryRelationtype {
+    IsReplacedBy = "is-replaced-by",
+    Triggers = "triggers"
+}
 /** An item that this catalog entry is related to */
 export interface CatalogEntryRelatedEntry extends BackboneElement {
     /** triggers | is-replaced-by */
-    relationtype: code;
+    relationtype: `${CatalogEntryRelationtype}`;
     _relationtype?: Element;
     /** The reference to the related item */
-    item: Reference<"CatalogEntry">;
+    item: Reference<'CatalogEntry'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CatalogEntry.js b/vendor/r4/types/hl7-fhir-r4-core/CatalogEntry.js
index c8ad2e5..b5a9480 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CatalogEntry.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/CatalogEntry.js
@@ -1,2 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalogEntryRelationtype = exports.CatalogEntryStatus = void 0;
+/** draft | active | retired | unknown */
+var CatalogEntryStatus;
+(function (CatalogEntryStatus) {
+    CatalogEntryStatus["Active"] = "active";
+    CatalogEntryStatus["Draft"] = "draft";
+    CatalogEntryStatus["Retired"] = "retired";
+    CatalogEntryStatus["Unknown"] = "unknown";
+})(CatalogEntryStatus = exports.CatalogEntryStatus || (exports.CatalogEntryStatus = {}));
+/** triggers | is-replaced-by */
+var CatalogEntryRelationtype;
+(function (CatalogEntryRelationtype) {
+    CatalogEntryRelationtype["IsReplacedBy"] = "is-replaced-by";
+    CatalogEntryRelationtype["Triggers"] = "triggers";
+})(CatalogEntryRelationtype = exports.CatalogEntryRelationtype || (exports.CatalogEntryRelationtype = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ChargeItem.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ChargeItem.d.ts
index 39dca2a..d225720 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ChargeItem.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ChargeItem.d.ts
@@ -12,22 +12,22 @@ import { DomainResource } from "./DomainResource";
 import { Money } from "./Money";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** The resource ChargeItem describes the provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons. Main Usage of the ChargeItem is to enable the billing process and internal cost allocation. */
 export interface ChargeItem extends DomainResource {
+    resourceType: 'ChargeItem';
     /** Which rendered service is being charged? */
     service?: Array<Reference>;
     /** Defining information about the code of this charge item */
     definitionUri?: Array<uri>;
     /** Individual who was entering */
-    enterer?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    enterer?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** Organization requesting the charged service */
-    requestingOrganization?: Reference<"Organization">;
+    requestingOrganization?: Reference<'Organization'>;
     productCodeableConcept?: CodeableConcept;
-    productReference?: Reference<"Medication" | "Device" | "Substance">;
+    productReference?: Reference<'Medication' | 'Device' | 'Substance'>;
     /** Resource defining the code of this ChargeItem */
     definitionCanonical?: Array<canonical>;
     _status?: Element;
@@ -36,7 +36,7 @@ export interface ChargeItem extends DomainResource {
     _definitionUri?: Array<Element>;
     occurrenceTiming?: Timing;
     /** Organization that has ownership of the (potential, future) revenue */
-    costCenter?: Reference<"Organization">;
+    costCenter?: Reference<'Organization'>;
     /** Comments made about the ChargeItem */
     note?: Array<Annotation>;
     /** Account to place this charge */
@@ -49,7 +49,7 @@ export interface ChargeItem extends DomainResource {
     supportingInformation?: Array<Reference>;
     occurrencePeriod?: Period;
     /** planned | billable | not-billable | aborted | billed | entered-in-error | unknown */
-    status: code;
+    status: `${ChargeItemStatus}`;
     _factorOverride?: Element;
     /** A code that identifies the charge, like a billing code */
     code: CodeableConcept;
@@ -57,7 +57,7 @@ export interface ChargeItem extends DomainResource {
     identifier?: Array<Identifier>;
     _enteredDate?: Element;
     /** Encounter / Episode associated with event */
-    context?: Reference<"EpisodeOfCare" | "Encounter">;
+    context?: Reference<'EpisodeOfCare' | 'Encounter'>;
     /** Quantity of which the charge item has been serviced */
     quantity?: Quantity;
     /** Part of referenced ChargeItem */
@@ -70,19 +70,29 @@ export interface ChargeItem extends DomainResource {
     /** Reason for overriding the list price/factor */
     overrideReason?: string;
     /** Organization providing the charged service */
-    performingOrganization?: Reference<"Organization">;
+    performingOrganization?: Reference<'Organization'>;
     /** Individual service was done for/to */
-    subject: Reference<"Patient" | "Group">;
+    subject: Reference<'Patient' | 'Group'>;
     /** Factor overriding the associated rules */
     factorOverride?: decimal;
     /** Who performed charged service */
     performer?: Array<ChargeItemPerformer>;
     _occurrenceDateTime?: Element;
 }
+/** planned | billable | not-billable | aborted | billed | entered-in-error | unknown */
+export declare enum ChargeItemStatus {
+    Aborted = "aborted",
+    Billable = "billable",
+    Billed = "billed",
+    EnteredInError = "entered-in-error",
+    NotBillable = "not-billable",
+    Planned = "planned",
+    Unknown = "unknown"
+}
 /** Who performed charged service */
 export interface ChargeItemPerformer extends BackboneElement {
     /** What type of performance was done */
     function?: CodeableConcept;
     /** Individual who was performing */
-    actor: Reference<"CareTeam" | "Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    actor: Reference<'CareTeam' | 'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ChargeItem.js b/vendor/r4/types/hl7-fhir-r4-core/ChargeItem.js
index c8ad2e5..bb9dab2 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ChargeItem.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ChargeItem.js
@@ -1,2 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChargeItemStatus = void 0;
+/** planned | billable | not-billable | aborted | billed | entered-in-error | unknown */
+var ChargeItemStatus;
+(function (ChargeItemStatus) {
+    ChargeItemStatus["Aborted"] = "aborted";
+    ChargeItemStatus["Billable"] = "billable";
+    ChargeItemStatus["Billed"] = "billed";
+    ChargeItemStatus["EnteredInError"] = "entered-in-error";
+    ChargeItemStatus["NotBillable"] = "not-billable";
+    ChargeItemStatus["Planned"] = "planned";
+    ChargeItemStatus["Unknown"] = "unknown";
+})(ChargeItemStatus = exports.ChargeItemStatus || (exports.ChargeItemStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ChargeItemDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ChargeItemDefinition.d.ts
index 0348107..3add2c6 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ChargeItemDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ChargeItemDefinition.d.ts
@@ -13,12 +13,12 @@ import { date } from "./date";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** The ChargeItemDefinition resource provides the properties that apply to the (billing) codes necessary to calculate costs and prices. The properties may differ largely depending on type and realm, therefore this resource gives only a rough structure and requires profiling for each type of billing code system. */
 export interface ChargeItemDefinition extends DomainResource {
+    resourceType: 'ChargeItemDefinition';
     /** Natural language description of the charge item definition */
     description?: markdown;
     /** Date last changed */
@@ -52,7 +52,7 @@ export interface ChargeItemDefinition extends DomainResource {
     derivedFromUri?: Array<uri>;
     _lastReviewDate?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${ChargeItemDefinitionStatus}`;
     _derivedFromUri?: Array<Element>;
     /** Canonical identifier for this charge item definition, represented as a URI (globally unique) */
     url: uri;
@@ -79,10 +79,19 @@ export interface ChargeItemDefinition extends DomainResource {
     /** When the charge item definition is expected to be used */
     effectivePeriod?: Period;
 }
+/** base | surcharge | deduction | discount | tax | informational */
+export declare enum ChargeItemDefinitionType {
+    Base = "base",
+    Deduction = "deduction",
+    Discount = "discount",
+    Informational = "informational",
+    Surcharge = "surcharge",
+    Tax = "tax"
+}
 /** Components of total line item price */
 export interface ChargeItemDefinitionPriceComponent extends BackboneElement {
     /** base | surcharge | deduction | discount | tax | informational */
-    type: code;
+    type: `${ChargeItemDefinitionType}`;
     _type?: Element;
     /** Code identifying the specific component */
     code?: CodeableConcept;
@@ -99,6 +108,13 @@ export interface ChargeItemDefinitionPropertyGroup extends BackboneElement {
     /** Components of total line item price */
     priceComponent?: Array<ChargeItemDefinitionPriceComponent>;
 }
+/** draft | active | retired | unknown */
+export declare enum ChargeItemDefinitionStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
 /** Whether or not the billing code is applicable */
 export interface ChargeItemDefinitionApplicability extends BackboneElement {
     /** Natural language description of the condition */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ChargeItemDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/ChargeItemDefinition.js
index c8ad2e5..6b74df0 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ChargeItemDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ChargeItemDefinition.js
@@ -1,2 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChargeItemDefinitionStatus = exports.ChargeItemDefinitionType = void 0;
+/** base | surcharge | deduction | discount | tax | informational */
+var ChargeItemDefinitionType;
+(function (ChargeItemDefinitionType) {
+    ChargeItemDefinitionType["Base"] = "base";
+    ChargeItemDefinitionType["Deduction"] = "deduction";
+    ChargeItemDefinitionType["Discount"] = "discount";
+    ChargeItemDefinitionType["Informational"] = "informational";
+    ChargeItemDefinitionType["Surcharge"] = "surcharge";
+    ChargeItemDefinitionType["Tax"] = "tax";
+})(ChargeItemDefinitionType = exports.ChargeItemDefinitionType || (exports.ChargeItemDefinitionType = {}));
+/** draft | active | retired | unknown */
+var ChargeItemDefinitionStatus;
+(function (ChargeItemDefinitionStatus) {
+    ChargeItemDefinitionStatus["Active"] = "active";
+    ChargeItemDefinitionStatus["Draft"] = "draft";
+    ChargeItemDefinitionStatus["Retired"] = "retired";
+    ChargeItemDefinitionStatus["Unknown"] = "unknown";
+})(ChargeItemDefinitionStatus = exports.ChargeItemDefinitionStatus || (exports.ChargeItemDefinitionStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Claim.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Claim.d.ts
index 3c6bc30..fcc6d77 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Claim.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Claim.d.ts
@@ -13,27 +13,27 @@ import { Money } from "./Money";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** A provider issued list of professional services and products which have been provided, or are to be provided, to a patient which is sent to an insurer for reimbursement. */
 export interface Claim extends DomainResource {
+    resourceType: 'Claim';
     _created?: Element;
     /** The recipient of the products and services */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** Patient insurance information */
     insurance: Array<ClaimInsurance>;
     /** Servicing facility */
-    facility?: Reference<"Location">;
+    facility?: Reference<'Location'>;
     /** Pertinent diagnosis information */
     diagnosis?: Array<ClaimDiagnosis>;
     /** Author of the claim */
-    enterer?: Reference<"PractitionerRole" | "Practitioner">;
+    enterer?: Reference<'PractitionerRole' | 'Practitioner'>;
     /** Supporting information */
     supportingInfo?: Array<ClaimSupportingInfo>;
     /** claim | preauthorization | predetermination */
-    use: code;
+    use: `${ClaimUse}`;
     /** Product or service provided */
     item?: Array<ClaimItem>;
     _status?: Element;
@@ -46,11 +46,11 @@ export interface Claim extends DomainResource {
     /** Prior or corollary claims */
     related?: Array<ClaimRelated>;
     /** Treatment referral */
-    referral?: Reference<"ServiceRequest">;
+    referral?: Reference<'ServiceRequest'>;
     /** Total claim cost */
     total?: Money;
     /** Target */
-    insurer?: Reference<"Organization">;
+    insurer?: Reference<'Organization'>;
     /** For whom to reserve funds */
     fundsReserve?: CodeableConcept;
     /** Desired processing ugency */
@@ -58,11 +58,11 @@ export interface Claim extends DomainResource {
     /** Details of the event */
     accident?: ClaimAccident;
     /** active | cancelled | draft | entered-in-error */
-    status: code;
+    status: `${ClaimStatus}`;
     /** Recipient of benefits payable */
     payee?: ClaimPayee;
     /** Prescription authorizing services and products */
-    prescription?: Reference<"VisionPrescription" | "DeviceRequest" | "MedicationRequest">;
+    prescription?: Reference<'VisionPrescription' | 'DeviceRequest' | 'MedicationRequest'>;
     /** Relevant time frame for the claim */
     billablePeriod?: Period;
     /** Business Identifier for claim */
@@ -70,9 +70,9 @@ export interface Claim extends DomainResource {
     /** More granular claim type */
     subType?: CodeableConcept;
     /** Party responsible for the claim */
-    provider: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    provider: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Original prescription if superseded by fulfiller */
-    originalPrescription?: Reference<"VisionPrescription" | "DeviceRequest" | "MedicationRequest">;
+    originalPrescription?: Reference<'VisionPrescription' | 'DeviceRequest' | 'MedicationRequest'>;
     _use?: Element;
     /** Members of the care team */
     careTeam?: Array<ClaimCareTeam>;
@@ -85,7 +85,7 @@ export interface ClaimAccident extends BackboneElement {
     /** The nature of the accident */
     type?: CodeableConcept;
     locationAddress?: Address;
-    locationReference?: Reference<"Location">;
+    locationReference?: Reference<'Location'>;
 }
 /** Pertinent diagnosis information */
 export interface ClaimDiagnosis extends BackboneElement {
@@ -93,7 +93,7 @@ export interface ClaimDiagnosis extends BackboneElement {
     sequence: positiveInt;
     _sequence?: Element;
     diagnosisCodeableConcept: CodeableConcept;
-    diagnosisReference: Reference<"Condition">;
+    diagnosisReference: Reference<'Condition'>;
     /** Timing or nature of the diagnosis */
     type?: Array<CodeableConcept>;
     /** Present on admission */
@@ -101,10 +101,16 @@ export interface ClaimDiagnosis extends BackboneElement {
     /** Package billing code */
     packageCode?: CodeableConcept;
 }
+/** claim | preauthorization | predetermination */
+export declare enum ClaimUse {
+    Claim = "claim",
+    Preauthorization = "preauthorization",
+    Predetermination = "predetermination"
+}
 /** Patient insurance information */
 export interface ClaimInsurance extends BackboneElement {
     /** Adjudication results */
-    claimResponse?: Reference<"ClaimResponse">;
+    claimResponse?: Reference<'ClaimResponse'>;
     _sequence?: Element;
     _focal?: Element;
     /** Prior authorization reference number */
@@ -114,7 +120,7 @@ export interface ClaimInsurance extends BackboneElement {
     /** Additional provider contract number */
     businessArrangement?: string;
     /** Insurance information */
-    coverage: Reference<"Coverage">;
+    coverage: Reference<'Coverage'>;
     /** Insurance instance identifier */
     sequence: positiveInt;
     /** Pre-assigned Claim number */
@@ -128,7 +134,7 @@ export interface ClaimProcedure extends BackboneElement {
     /** When the procedure was performed */
     date?: dateTime;
     procedureCodeableConcept: CodeableConcept;
-    procedureReference: Reference<"Procedure">;
+    procedureReference: Reference<'Procedure'>;
     _date?: Element;
     /** Category of Procedure */
     type?: Array<CodeableConcept>;
@@ -143,7 +149,7 @@ export interface ClaimCareTeam extends BackboneElement {
     sequence: positiveInt;
     _sequence?: Element;
     /** Practitioner or organization */
-    provider: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    provider: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Indicator of the lead practitioner */
     responsible?: boolean;
     _responsible?: Element;
@@ -155,7 +161,7 @@ export interface ClaimCareTeam extends BackboneElement {
 /** Prior or corollary claims */
 export interface ClaimRelated extends BackboneElement {
     /** Reference to the related claim */
-    claim?: Reference<"Claim">;
+    claim?: Reference<'Claim'>;
     /** How the reference claim is related */
     relationship?: CodeableConcept;
     /** File or case reference */
@@ -210,6 +216,13 @@ export interface ClaimSubDetail extends BackboneElement {
     /** Fee, charge or cost per item */
     unitPrice?: Money;
 }
+/** active | cancelled | draft | entered-in-error */
+export declare enum ClaimStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    EnteredInError = "entered-in-error"
+}
 /** Product or service provided */
 export interface ClaimDetail extends BackboneElement {
     /** Benefit classification */
@@ -268,7 +281,7 @@ export interface ClaimItem extends BackboneElement {
     /** Billing, service, product, or drug code */
     productOrService: CodeableConcept;
     _informationSequence?: Array<Element>;
-    locationReference?: Reference<"Location">;
+    locationReference?: Reference<'Location'>;
     /** Unique device identifier */
     udi?: Array<Reference>;
     /** Applicable exception and supporting information */
@@ -297,5 +310,5 @@ export interface ClaimPayee extends BackboneElement {
     /** Category of recipient */
     type: CodeableConcept;
     /** Recipient reference */
-    party?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Practitioner" | "RelatedPerson">;
+    party?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Practitioner' | 'RelatedPerson'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Claim.js b/vendor/r4/types/hl7-fhir-r4-core/Claim.js
index c8ad2e5..b2b4ba0 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Claim.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Claim.js
@@ -1,2 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaimStatus = exports.ClaimUse = void 0;
+/** claim | preauthorization | predetermination */
+var ClaimUse;
+(function (ClaimUse) {
+    ClaimUse["Claim"] = "claim";
+    ClaimUse["Preauthorization"] = "preauthorization";
+    ClaimUse["Predetermination"] = "predetermination";
+})(ClaimUse = exports.ClaimUse || (exports.ClaimUse = {}));
+/** active | cancelled | draft | entered-in-error */
+var ClaimStatus;
+(function (ClaimStatus) {
+    ClaimStatus["Active"] = "active";
+    ClaimStatus["Cancelled"] = "cancelled";
+    ClaimStatus["Draft"] = "draft";
+    ClaimStatus["EnteredInError"] = "entered-in-error";
+})(ClaimStatus = exports.ClaimStatus || (exports.ClaimStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ClaimResponse.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ClaimResponse.d.ts
index 6bfe1ef..2984d5d 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ClaimResponse.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ClaimResponse.d.ts
@@ -12,23 +12,23 @@ import { Money } from "./Money";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** This resource provides the adjudication details from the processing of a Claim resource. */
 export interface ClaimResponse extends DomainResource {
+    resourceType: 'ClaimResponse';
     _created?: Element;
     /** The recipient of the products and services */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** Party responsible for the claim */
-    requestor?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    requestor?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Party to be paid any benefits payable */
     payeeType?: CodeableConcept;
     /** Patient insurance information */
     insurance?: Array<ClaimResponseInsurance>;
     /** Id of resource triggering adjudication */
-    request?: Reference<"Claim">;
+    request?: Reference<'Claim'>;
     /** Note concerning adjudication */
     processNote?: Array<ClaimResponseProcessNote>;
     /** Preauthorization reference */
@@ -37,7 +37,7 @@ export interface ClaimResponse extends DomainResource {
     adjudication?: Array<ClaimResponseItemAdjudication>;
     _disposition?: Element;
     /** claim | preauthorization | predetermination */
-    use: code;
+    use: `${ClaimResponseUse}`;
     /** Payment Details */
     payment?: ClaimResponsePayment;
     /** Adjudication for claim line items */
@@ -50,7 +50,7 @@ export interface ClaimResponse extends DomainResource {
     /** Preauthorization reference effective period */
     preAuthPeriod?: Period;
     /** queued | complete | error | partial */
-    outcome: code;
+    outcome: `${ClaimResponseOutcome}`;
     _outcome?: Element;
     /** Disposition Message */
     disposition?: string;
@@ -59,11 +59,11 @@ export interface ClaimResponse extends DomainResource {
     /** Adjudication totals */
     total?: Array<ClaimResponseTotal>;
     /** Party responsible for reimbursement */
-    insurer: Reference<"Organization">;
+    insurer: Reference<'Organization'>;
     /** Funds reserved status */
     fundsReserve?: CodeableConcept;
     /** active | cancelled | draft | entered-in-error */
-    status: code;
+    status: `${ClaimResponseStatus}`;
     /** Business Identifier for a claim response */
     identifier?: Array<Identifier>;
     /** Processing errors */
@@ -79,6 +79,12 @@ export interface ClaimResponse extends DomainResource {
     addItem?: Array<ClaimResponseAddItem>;
     _use?: Element;
 }
+/** claim | preauthorization | predetermination */
+export declare enum ClaimResponseUse {
+    Claim = "claim",
+    Preauthorization = "preauthorization",
+    Predetermination = "predetermination"
+}
 /** Adjudication for claim line items */
 export interface ClaimResponseItem extends BackboneElement {
     /** Claim item instance identifier */
@@ -98,6 +104,12 @@ export interface ClaimResponseTotal extends BackboneElement {
     /** Financial total for the category */
     amount: Money;
 }
+/** display | print | printoper */
+export declare enum ClaimResponseType {
+    Display = "display",
+    Print = "print",
+    Printoper = "printoper"
+}
 /** Payment Details */
 export interface ClaimResponsePayment extends BackboneElement {
     /** Partial or complete payment */
@@ -128,6 +140,13 @@ export interface ClaimResponseError extends BackboneElement {
     /** Error code detailing processing issues */
     code: CodeableConcept;
 }
+/** active | cancelled | draft | entered-in-error */
+export declare enum ClaimResponseStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    EnteredInError = "entered-in-error"
+}
 /** Adjudication for claim details */
 export interface ClaimResponseDetail extends BackboneElement {
     /** Claim detail instance identifier */
@@ -141,13 +160,20 @@ export interface ClaimResponseDetail extends BackboneElement {
     /** Adjudication for claim sub-details */
     subDetail?: Array<ClaimResponseSubDetail>;
 }
+/** queued | complete | error | partial */
+export declare enum ClaimResponseOutcome {
+    Complete = "complete",
+    Error = "error",
+    Partial = "partial",
+    Queued = "queued"
+}
 /** Note concerning adjudication */
 export interface ClaimResponseProcessNote extends BackboneElement {
     /** Note instance identifier */
     number?: positiveInt;
     _number?: Element;
     /** display | print | printoper */
-    type?: code;
+    type?: `${ClaimResponseType}`;
     _type?: Element;
     /** Note explanatory text */
     text: string;
@@ -178,7 +204,7 @@ export interface ClaimResponseAddItem extends BackboneElement {
     subSite?: Array<CodeableConcept>;
     /** Billing, service, product, or drug code */
     productOrService: CodeableConcept;
-    locationReference?: Reference<"Location">;
+    locationReference?: Reference<'Location'>;
     _detailSequence?: Array<Element>;
     _itemSequence?: Array<Element>;
     /** Program the product or service is provided under */
@@ -210,12 +236,12 @@ export interface ClaimResponseInsurance extends BackboneElement {
     focal: boolean;
     _focal?: Element;
     /** Insurance information */
-    coverage: Reference<"Coverage">;
+    coverage: Reference<'Coverage'>;
     /** Additional provider contract number */
     businessArrangement?: string;
     _businessArrangement?: Element;
     /** Adjudication results */
-    claimResponse?: Reference<"ClaimResponse">;
+    claimResponse?: Reference<'ClaimResponse'>;
 }
 /** Adjudication for claim sub-details */
 export interface ClaimResponseSubDetail extends BackboneElement {
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ClaimResponse.js b/vendor/r4/types/hl7-fhir-r4-core/ClaimResponse.js
index c8ad2e5..99c8e64 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ClaimResponse.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ClaimResponse.js
@@ -1,2 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaimResponseOutcome = exports.ClaimResponseStatus = exports.ClaimResponseType = exports.ClaimResponseUse = void 0;
+/** claim | preauthorization | predetermination */
+var ClaimResponseUse;
+(function (ClaimResponseUse) {
+    ClaimResponseUse["Claim"] = "claim";
+    ClaimResponseUse["Preauthorization"] = "preauthorization";
+    ClaimResponseUse["Predetermination"] = "predetermination";
+})(ClaimResponseUse = exports.ClaimResponseUse || (exports.ClaimResponseUse = {}));
+/** display | print | printoper */
+var ClaimResponseType;
+(function (ClaimResponseType) {
+    ClaimResponseType["Display"] = "display";
+    ClaimResponseType["Print"] = "print";
+    ClaimResponseType["Printoper"] = "printoper";
+})(ClaimResponseType = exports.ClaimResponseType || (exports.ClaimResponseType = {}));
+/** active | cancelled | draft | entered-in-error */
+var ClaimResponseStatus;
+(function (ClaimResponseStatus) {
+    ClaimResponseStatus["Active"] = "active";
+    ClaimResponseStatus["Cancelled"] = "cancelled";
+    ClaimResponseStatus["Draft"] = "draft";
+    ClaimResponseStatus["EnteredInError"] = "entered-in-error";
+})(ClaimResponseStatus = exports.ClaimResponseStatus || (exports.ClaimResponseStatus = {}));
+/** queued | complete | error | partial */
+var ClaimResponseOutcome;
+(function (ClaimResponseOutcome) {
+    ClaimResponseOutcome["Complete"] = "complete";
+    ClaimResponseOutcome["Error"] = "error";
+    ClaimResponseOutcome["Partial"] = "partial";
+    ClaimResponseOutcome["Queued"] = "queued";
+})(ClaimResponseOutcome = exports.ClaimResponseOutcome || (exports.ClaimResponseOutcome = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ClinicalImpression.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ClinicalImpression.d.ts
index 8825fcf..efb1c45 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ClinicalImpression.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ClinicalImpression.d.ts
@@ -8,11 +8,11 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A record of a clinical assessment performed to determine what problem(s) may affect the patient and before planning the treatments or management strategies that are best to manage a patient's condition. Assessments are often 1:1 with a clinical consultation / encounter,  but this varies greatly depending on the clinical workflow. This resource is called "ClinicalImpression" rather than "ClinicalAssessment" to avoid confusion with the recording of assessment tools such as Apgar score. */
 export interface ClinicalImpression extends DomainResource {
+    resourceType: 'ClinicalImpression';
     /** Why/how the assessment was performed */
     description?: string;
     /** When the assessment was documented */
@@ -23,11 +23,11 @@ export interface ClinicalImpression extends DomainResource {
     /** Clinical Protocol followed */
     protocol?: Array<uri>;
     /** The clinician performing the assessment */
-    assessor?: Reference<"PractitionerRole" | "Practitioner">;
+    assessor?: Reference<'PractitionerRole' | 'Practitioner'>;
     /** Information supporting the clinical impression */
     supportingInfo?: Array<Reference>;
     /** Encounter created as part of */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _date?: Element;
     _status?: Element;
     /** Relevant impressions of patient state */
@@ -44,9 +44,9 @@ export interface ClinicalImpression extends DomainResource {
     /** Estimate of likely outcome */
     prognosisCodeableConcept?: Array<CodeableConcept>;
     /** in-progress | completed | entered-in-error */
-    status: code;
+    status: `${ClinicalImpressionStatus}`;
     /** Reference to last assessment */
-    previous?: Reference<"ClinicalImpression">;
+    previous?: Reference<'ClinicalImpression'>;
     /** Kind of assessment performed */
     code?: CodeableConcept;
     /** Business identifier */
@@ -57,7 +57,7 @@ export interface ClinicalImpression extends DomainResource {
     /** RiskAssessment expressing likely outcome */
     prognosisReference?: Array<Reference>;
     /** Patient or group assessed */
-    subject: Reference<"Patient" | "Group">;
+    subject: Reference<'Patient' | 'Group'>;
     effectivePeriod?: Period;
 }
 /** One or more sets of investigations (signs, symptoms, etc.) */
@@ -67,12 +67,18 @@ export interface ClinicalImpressionInvestigation extends BackboneElement {
     /** Record of a specific investigation */
     item?: Array<Reference>;
 }
+/** in-progress | completed | entered-in-error */
+export declare enum ClinicalImpressionStatus {
+    Completed = "completed",
+    EnteredInError = "entered-in-error",
+    InProgress = "in-progress"
+}
 /** Possible or likely findings and diagnoses */
 export interface ClinicalImpressionFinding extends BackboneElement {
     /** What was found */
     itemCodeableConcept?: CodeableConcept;
     /** What was found */
-    itemReference?: Reference<"Media" | "Observation" | "Condition">;
+    itemReference?: Reference<'Media' | 'Observation' | 'Condition'>;
     /** Which investigations support finding */
     basis?: string;
     _basis?: Element;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ClinicalImpression.js b/vendor/r4/types/hl7-fhir-r4-core/ClinicalImpression.js
index c8ad2e5..42f1679 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ClinicalImpression.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ClinicalImpression.js
@@ -1,2 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClinicalImpressionStatus = void 0;
+/** in-progress | completed | entered-in-error */
+var ClinicalImpressionStatus;
+(function (ClinicalImpressionStatus) {
+    ClinicalImpressionStatus["Completed"] = "completed";
+    ClinicalImpressionStatus["EnteredInError"] = "entered-in-error";
+    ClinicalImpressionStatus["InProgress"] = "in-progress";
+})(ClinicalImpressionStatus = exports.ClinicalImpressionStatus || (exports.ClinicalImpressionStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CodeSystem.d.ts b/vendor/r4/types/hl7-fhir-r4-core/CodeSystem.d.ts
index 2548d3d..62006b1 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CodeSystem.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/CodeSystem.d.ts
@@ -18,6 +18,7 @@ import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** The CodeSystem resource is used to declare the existence of and describe a code system or code system supplement and its key properties, and optionally define a part or all of its content. */
 export interface CodeSystem extends DomainResource {
+    resourceType: 'CodeSystem';
     _supplements?: Element;
     /** Natural language description of the code system */
     description?: markdown;
@@ -37,7 +38,7 @@ export interface CodeSystem extends DomainResource {
     /** Why this code system is defined */
     purpose?: markdown;
     /** not-present | example | fragment | complete | supplement */
-    content: code;
+    content: `${CodeSystemContent}`;
     _date?: Element;
     /** Additional information supplied about each concept */
     property?: Array<CodeSystemProperty>;
@@ -63,9 +64,9 @@ export interface CodeSystem extends DomainResource {
     /** If code system defines a compositional grammar */
     compositional?: boolean;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${CodeSystemStatus}`;
     /** grouped-by | is-a | part-of | classified-with */
-    hierarchyMeaning?: code;
+    hierarchyMeaning?: `${CodeSystemHierarchyMeaning}`;
     /** Canonical reference to the value set with entire code system */
     valueSet?: canonical;
     _name?: Element;
@@ -89,21 +90,6 @@ export interface CodeSystem extends DomainResource {
     contact?: Array<ContactDetail>;
     _url?: Element;
 }
-/** Additional information supplied about each concept */
-export interface CodeSystemProperty extends BackboneElement {
-    /** Identifies the property on the concepts, and when referred to in operations */
-    code: code;
-    _code?: Element;
-    /** Formal identifier for the property */
-    uri?: uri;
-    _uri?: Element;
-    /** Why the property is defined, and/or what it conveys */
-    description?: string;
-    _description?: Element;
-    /** code | Coding | string | integer | boolean | dateTime | decimal */
-    type: code;
-    _type?: Element;
-}
 /** Filter that can be used in a value set */
 export interface CodeSystemFilter extends BackboneElement {
     /** Code that identifies the filter */
@@ -119,24 +105,12 @@ export interface CodeSystemFilter extends BackboneElement {
     value: string;
     _value?: Element;
 }
-/** Property value for the concept */
-export interface CodeSystemConceptProperty extends BackboneElement {
-    _code?: Element;
-    valueCode: code;
-    _valueBoolean: Element;
-    valueDecimal: decimal;
-    _valueDecimal: Element;
-    _valueString: Element;
-    valueString: string;
-    valueBoolean: boolean;
-    valueDateTime: dateTime;
-    valueCoding: Coding;
-    _valueDateTime: Element;
-    /** Reference to CodeSystem.property.code */
-    code: code;
-    valueInteger: integer;
-    _valueCode: Element;
-    _valueInteger: Element;
+/** grouped-by | is-a | part-of | classified-with */
+export declare enum CodeSystemHierarchyMeaning {
+    ClassifiedWith = "classified-with",
+    GroupedBy = "grouped-by",
+    IsA = "is-a",
+    PartOf = "part-of"
 }
 /** Additional representations for the concept */
 export interface CodeSystemConceptDesignation extends BackboneElement {
@@ -149,6 +123,31 @@ export interface CodeSystemConceptDesignation extends BackboneElement {
     value: string;
     _value?: Element;
 }
+/** code | Coding | string | integer | boolean | dateTime | decimal */
+export declare enum CodeSystemType {
+    Coding = "Coding",
+    Boolean = "boolean",
+    Code = "code",
+    DateTime = "dateTime",
+    Decimal = "decimal",
+    Integer = "integer",
+    String = "string"
+}
+/** Additional information supplied about each concept */
+export interface CodeSystemProperty extends BackboneElement {
+    /** Identifies the property on the concepts, and when referred to in operations */
+    code: code;
+    _code?: Element;
+    /** Formal identifier for the property */
+    uri?: uri;
+    _uri?: Element;
+    /** Why the property is defined, and/or what it conveys */
+    description?: string;
+    _description?: Element;
+    /** code | Coding | string | integer | boolean | dateTime | decimal */
+    type: `${CodeSystemType}`;
+    _type?: Element;
+}
 /** Concepts in the code system */
 export interface CodeSystemConcept extends BackboneElement {
     _code?: Element;
@@ -167,3 +166,37 @@ export interface CodeSystemConcept extends BackboneElement {
     designation?: Array<CodeSystemConceptDesignation>;
     _display?: Element;
 }
+/** not-present | example | fragment | complete | supplement */
+export declare enum CodeSystemContent {
+    Complete = "complete",
+    Example = "example",
+    Fragment = "fragment",
+    NotPresent = "not-present",
+    Supplement = "supplement"
+}
+/** draft | active | retired | unknown */
+export declare enum CodeSystemStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** Property value for the concept */
+export interface CodeSystemConceptProperty extends BackboneElement {
+    _code?: Element;
+    valueCode: code;
+    _valueBoolean: Element;
+    valueDecimal: decimal;
+    _valueDecimal: Element;
+    _valueString: Element;
+    valueString: string;
+    valueBoolean: boolean;
+    valueDateTime: dateTime;
+    valueCoding: Coding;
+    _valueDateTime: Element;
+    /** Reference to CodeSystem.property.code */
+    code: code;
+    valueInteger: integer;
+    _valueCode: Element;
+    _valueInteger: Element;
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CodeSystem.js b/vendor/r4/types/hl7-fhir-r4-core/CodeSystem.js
index c8ad2e5..e4a562d 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CodeSystem.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/CodeSystem.js
@@ -1,2 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeSystemStatus = exports.CodeSystemContent = exports.CodeSystemType = exports.CodeSystemHierarchyMeaning = void 0;
+/** grouped-by | is-a | part-of | classified-with */
+var CodeSystemHierarchyMeaning;
+(function (CodeSystemHierarchyMeaning) {
+    CodeSystemHierarchyMeaning["ClassifiedWith"] = "classified-with";
+    CodeSystemHierarchyMeaning["GroupedBy"] = "grouped-by";
+    CodeSystemHierarchyMeaning["IsA"] = "is-a";
+    CodeSystemHierarchyMeaning["PartOf"] = "part-of";
+})(CodeSystemHierarchyMeaning = exports.CodeSystemHierarchyMeaning || (exports.CodeSystemHierarchyMeaning = {}));
+/** code | Coding | string | integer | boolean | dateTime | decimal */
+var CodeSystemType;
+(function (CodeSystemType) {
+    CodeSystemType["Coding"] = "Coding";
+    CodeSystemType["Boolean"] = "boolean";
+    CodeSystemType["Code"] = "code";
+    CodeSystemType["DateTime"] = "dateTime";
+    CodeSystemType["Decimal"] = "decimal";
+    CodeSystemType["Integer"] = "integer";
+    CodeSystemType["String"] = "string";
+})(CodeSystemType = exports.CodeSystemType || (exports.CodeSystemType = {}));
+/** not-present | example | fragment | complete | supplement */
+var CodeSystemContent;
+(function (CodeSystemContent) {
+    CodeSystemContent["Complete"] = "complete";
+    CodeSystemContent["Example"] = "example";
+    CodeSystemContent["Fragment"] = "fragment";
+    CodeSystemContent["NotPresent"] = "not-present";
+    CodeSystemContent["Supplement"] = "supplement";
+})(CodeSystemContent = exports.CodeSystemContent || (exports.CodeSystemContent = {}));
+/** draft | active | retired | unknown */
+var CodeSystemStatus;
+(function (CodeSystemStatus) {
+    CodeSystemStatus["Active"] = "active";
+    CodeSystemStatus["Draft"] = "draft";
+    CodeSystemStatus["Retired"] = "retired";
+    CodeSystemStatus["Unknown"] = "unknown";
+})(CodeSystemStatus = exports.CodeSystemStatus || (exports.CodeSystemStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Communication.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Communication.d.ts
index 0169990..1d3e5fa 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Communication.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Communication.d.ts
@@ -9,11 +9,11 @@ import { canonical } from "./canonical";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency that was notified about a reportable condition. */
 export interface Communication extends DomainResource {
+    resourceType: 'Communication';
     /** Message category */
     category?: Array<CodeableConcept>;
     /** When received */
@@ -26,7 +26,7 @@ export interface Communication extends DomainResource {
     instantiatesUri?: Array<uri>;
     _received?: Element;
     /** Encounter created as part of */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     /** A channel of communication */
     medium?: Array<CodeableConcept>;
     _priority?: Element;
@@ -44,11 +44,11 @@ export interface Communication extends DomainResource {
     /** Comments made about the communication */
     note?: Array<Annotation>;
     /** routine | urgent | asap | stat */
-    priority?: code;
+    priority?: `${CommunicationPriority}`;
     /** preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown */
-    status: code;
+    status: `${CommunicationStatus}`;
     /** Message sender */
-    sender?: Reference<"Patient" | "PractitionerRole" | "HealthcareService" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    sender?: Reference<'Patient' | 'PractitionerRole' | 'HealthcareService' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** Unique identifier */
     identifier?: Array<Identifier>;
     /** Reply to */
@@ -59,7 +59,7 @@ export interface Communication extends DomainResource {
     partOf?: Array<Reference>;
     _instantiatesCanonical?: Array<Element>;
     /** Focus of message */
-    subject?: Reference<"Patient" | "Group">;
+    subject?: Reference<'Patient' | 'Group'>;
     /** Resources that pertain to this communication */
     about?: Array<Reference>;
     /** Why was communication done? */
@@ -74,3 +74,21 @@ export interface CommunicationPayload extends BackboneElement {
     contentAttachment: Attachment;
     contentReference: Reference;
 }
+/** routine | urgent | asap | stat */
+export declare enum CommunicationPriority {
+    Asap = "asap",
+    Routine = "routine",
+    Stat = "stat",
+    Urgent = "urgent"
+}
+/** preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown */
+export declare enum CommunicationStatus {
+    Completed = "completed",
+    EnteredInError = "entered-in-error",
+    InProgress = "in-progress",
+    NotDone = "not-done",
+    OnHold = "on-hold",
+    Preparation = "preparation",
+    Stopped = "stopped",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Communication.js b/vendor/r4/types/hl7-fhir-r4-core/Communication.js
index c8ad2e5..08790af 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Communication.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Communication.js
@@ -1,2 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunicationStatus = exports.CommunicationPriority = void 0;
+/** routine | urgent | asap | stat */
+var CommunicationPriority;
+(function (CommunicationPriority) {
+    CommunicationPriority["Asap"] = "asap";
+    CommunicationPriority["Routine"] = "routine";
+    CommunicationPriority["Stat"] = "stat";
+    CommunicationPriority["Urgent"] = "urgent";
+})(CommunicationPriority = exports.CommunicationPriority || (exports.CommunicationPriority = {}));
+/** preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown */
+var CommunicationStatus;
+(function (CommunicationStatus) {
+    CommunicationStatus["Completed"] = "completed";
+    CommunicationStatus["EnteredInError"] = "entered-in-error";
+    CommunicationStatus["InProgress"] = "in-progress";
+    CommunicationStatus["NotDone"] = "not-done";
+    CommunicationStatus["OnHold"] = "on-hold";
+    CommunicationStatus["Preparation"] = "preparation";
+    CommunicationStatus["Stopped"] = "stopped";
+    CommunicationStatus["Unknown"] = "unknown";
+})(CommunicationStatus = exports.CommunicationStatus || (exports.CommunicationStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CommunicationRequest.d.ts b/vendor/r4/types/hl7-fhir-r4-core/CommunicationRequest.d.ts
index 7d5e647..68d8168 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CommunicationRequest.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/CommunicationRequest.d.ts
@@ -8,18 +8,18 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A request to convey information; e.g. the CDS system proposes that an alert be sent to a responsible provider, the CDS system proposes that the public health agency be notified about a reportable condition. */
 export interface CommunicationRequest extends DomainResource {
+    resourceType: 'CommunicationRequest';
     /** Message category */
     category?: Array<CodeableConcept>;
     /** Message payload */
     payload?: Array<CommunicationRequestPayload>;
     _authoredOn?: Element;
     /** Encounter created as part of */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     /** A channel of communication */
     medium?: Array<CodeableConcept>;
     _doNotPerform?: Element;
@@ -36,16 +36,16 @@ export interface CommunicationRequest extends DomainResource {
     /** Comments made about communication request */
     note?: Array<Annotation>;
     /** Who/what is requesting service */
-    requester?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    requester?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** routine | urgent | asap | stat */
-    priority?: code;
+    priority?: `${CommunicationRequestPriority}`;
     occurrencePeriod?: Period;
     /** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
-    status: code;
+    status: `${CommunicationRequestStatus}`;
     /** Composite request this is part of */
     groupIdentifier?: Identifier;
     /** Message sender */
-    sender?: Reference<"Patient" | "PractitionerRole" | "HealthcareService" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    sender?: Reference<'Patient' | 'PractitionerRole' | 'HealthcareService' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** Unique identifier */
     identifier?: Array<Identifier>;
     /** True if request is prohibiting action */
@@ -56,7 +56,7 @@ export interface CommunicationRequest extends DomainResource {
     basedOn?: Array<Reference>;
     occurrenceDateTime?: dateTime;
     /** Focus of message */
-    subject?: Reference<"Patient" | "Group">;
+    subject?: Reference<'Patient' | 'Group'>;
     /** Resources that pertain to this communication request */
     about?: Array<Reference>;
     /** Why is communication needed? */
@@ -70,3 +70,20 @@ export interface CommunicationRequestPayload extends BackboneElement {
     contentAttachment: Attachment;
     contentReference: Reference;
 }
+/** routine | urgent | asap | stat */
+export declare enum CommunicationRequestPriority {
+    Asap = "asap",
+    Routine = "routine",
+    Stat = "stat",
+    Urgent = "urgent"
+}
+/** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
+export declare enum CommunicationRequestStatus {
+    Active = "active",
+    Completed = "completed",
+    Draft = "draft",
+    EnteredInError = "entered-in-error",
+    OnHold = "on-hold",
+    Revoked = "revoked",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CommunicationRequest.js b/vendor/r4/types/hl7-fhir-r4-core/CommunicationRequest.js
index c8ad2e5..da79c15 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CommunicationRequest.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/CommunicationRequest.js
@@ -1,2 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunicationRequestStatus = exports.CommunicationRequestPriority = void 0;
+/** routine | urgent | asap | stat */
+var CommunicationRequestPriority;
+(function (CommunicationRequestPriority) {
+    CommunicationRequestPriority["Asap"] = "asap";
+    CommunicationRequestPriority["Routine"] = "routine";
+    CommunicationRequestPriority["Stat"] = "stat";
+    CommunicationRequestPriority["Urgent"] = "urgent";
+})(CommunicationRequestPriority = exports.CommunicationRequestPriority || (exports.CommunicationRequestPriority = {}));
+/** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
+var CommunicationRequestStatus;
+(function (CommunicationRequestStatus) {
+    CommunicationRequestStatus["Active"] = "active";
+    CommunicationRequestStatus["Completed"] = "completed";
+    CommunicationRequestStatus["Draft"] = "draft";
+    CommunicationRequestStatus["EnteredInError"] = "entered-in-error";
+    CommunicationRequestStatus["OnHold"] = "on-hold";
+    CommunicationRequestStatus["Revoked"] = "revoked";
+    CommunicationRequestStatus["Unknown"] = "unknown";
+})(CommunicationRequestStatus = exports.CommunicationRequestStatus || (exports.CommunicationRequestStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CompartmentDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/CompartmentDefinition.d.ts
index 4d26e0c..3827ead 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CompartmentDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/CompartmentDefinition.d.ts
@@ -7,10 +7,10 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
-import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** A compartment definition that defines how resources are accessed on a server. */
 export interface CompartmentDefinition extends DomainResource {
+    resourceType: 'CompartmentDefinition';
     /** Natural language description of the compartment definition */
     description?: markdown;
     _code?: Element;
@@ -36,14 +36,14 @@ export interface CompartmentDefinition extends DomainResource {
     _search?: Element;
     _purpose?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${CompartmentDefinitionStatus}`;
     /** How a resource is related to the compartment */
     resource?: Array<CompartmentDefinitionResource>;
     _name?: Element;
     /** Canonical identifier for this compartment definition, represented as a URI (globally unique) */
     url: uri;
     /** Patient | Encounter | RelatedPerson | Practitioner | Device */
-    code: code;
+    code: `${CompartmentDefinitionCode}`;
     /** Business version of the compartment definition */
     version?: string;
     _version?: Element;
@@ -51,10 +51,25 @@ export interface CompartmentDefinition extends DomainResource {
     contact?: Array<ContactDetail>;
     _url?: Element;
 }
+/** draft | active | retired | unknown */
+export declare enum CompartmentDefinitionStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** Patient | Encounter | RelatedPerson | Practitioner | Device */
+export declare enum CompartmentDefinitionCode {
+    Device = "Device",
+    Encounter = "Encounter",
+    Patient = "Patient",
+    Practitioner = "Practitioner",
+    RelatedPerson = "RelatedPerson"
+}
 /** How a resource is related to the compartment */
 export interface CompartmentDefinitionResource extends BackboneElement {
     /** Name of resource type */
-    code: code;
+    code: `${CompartmentDefinitionCode}`;
     _code?: Element;
     /** Search Parameter Name, or chained parameters */
     param?: Array<string>;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CompartmentDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/CompartmentDefinition.js
index c8ad2e5..b5afb1f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CompartmentDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/CompartmentDefinition.js
@@ -1,2 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompartmentDefinitionCode = exports.CompartmentDefinitionStatus = void 0;
+/** draft | active | retired | unknown */
+var CompartmentDefinitionStatus;
+(function (CompartmentDefinitionStatus) {
+    CompartmentDefinitionStatus["Active"] = "active";
+    CompartmentDefinitionStatus["Draft"] = "draft";
+    CompartmentDefinitionStatus["Retired"] = "retired";
+    CompartmentDefinitionStatus["Unknown"] = "unknown";
+})(CompartmentDefinitionStatus = exports.CompartmentDefinitionStatus || (exports.CompartmentDefinitionStatus = {}));
+/** Patient | Encounter | RelatedPerson | Practitioner | Device */
+var CompartmentDefinitionCode;
+(function (CompartmentDefinitionCode) {
+    CompartmentDefinitionCode["Device"] = "Device";
+    CompartmentDefinitionCode["Encounter"] = "Encounter";
+    CompartmentDefinitionCode["Patient"] = "Patient";
+    CompartmentDefinitionCode["Practitioner"] = "Practitioner";
+    CompartmentDefinitionCode["RelatedPerson"] = "RelatedPerson";
+})(CompartmentDefinitionCode = exports.CompartmentDefinitionCode || (exports.CompartmentDefinitionCode = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Composition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Composition.d.ts
index d73a810..c1dddcb 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Composition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Composition.d.ts
@@ -6,18 +6,18 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { Narrative } from "./Narrative";
 /** A set of healthcare-related information that is assembled together into a single logical package that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. A Composition defines the structure and narrative content necessary for a document. However, a Composition alone does not constitute a document. Rather, the Composition must be the first entry in a Bundle where Bundle.type=document, and any other resources referenced from Composition must be included as subsequent entries in the Bundle (for example Patient, Practitioner, Encounter, etc.). */
 export interface Composition extends DomainResource {
+    resourceType: 'Composition';
     /** Categorization of Composition */
     category?: Array<CodeableConcept>;
     /** Composition editing time */
     date: dateTime;
     /** Context of the Composition */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _date?: Element;
     section?: Array<CompositionSection>;
     _status?: Element;
@@ -33,9 +33,9 @@ export interface Composition extends DomainResource {
     /** The clinical service(s) being documented */
     event?: Array<CompositionEvent>;
     /** Organization which maintains the composition */
-    custodian?: Reference<"Organization">;
+    custodian?: Reference<'Organization'>;
     /** preliminary | final | amended | entered-in-error */
-    status: code;
+    status: `${CompositionStatus}`;
     /** Version-independent identifier for the Composition */
     identifier?: Identifier;
     /** Relationships to other compositions/documents */
@@ -44,18 +44,13 @@ export interface Composition extends DomainResource {
     /** Who and/or what the composition is about */
     subject?: Reference;
     /** As defined by affinity domain */
-    confidentiality?: code;
+    confidentiality?: `${CompositionConfidentiality}`;
 }
-/** Attests to accuracy of composition */
-export interface CompositionAttester extends BackboneElement {
-    /** personal | professional | legal | official */
-    mode: code;
-    _mode?: Element;
-    /** When the composition was attested */
-    time?: dateTime;
-    _time?: Element;
-    /** Who attested the composition */
-    party?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Practitioner" | "RelatedPerson">;
+/** working | snapshot | changes */
+export declare enum CompositionSectionMode {
+    Changes = "changes",
+    Snapshot = "snapshot",
+    Working = "working"
 }
 /** The clinical service(s) being documented */
 export interface CompositionEvent extends BackboneElement {
@@ -66,13 +61,54 @@ export interface CompositionEvent extends BackboneElement {
     /** The event(s) being documented */
     detail?: Array<Reference>;
 }
+/** Attests to accuracy of composition */
+export interface CompositionAttester extends BackboneElement {
+    /** personal | professional | legal | official */
+    mode: `${CompositionMode}`;
+    _mode?: Element;
+    /** When the composition was attested */
+    time?: dateTime;
+    _time?: Element;
+    /** Who attested the composition */
+    party?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Practitioner' | 'RelatedPerson'>;
+}
+/** As defined by affinity domain */
+export declare enum CompositionConfidentiality {
+    L = "L",
+    M = "M",
+    R = "R",
+    V = "V",
+    U = "U",
+    N = "N"
+}
+/** personal | professional | legal | official */
+export declare enum CompositionMode {
+    Legal = "legal",
+    Official = "official",
+    Personal = "personal",
+    Professional = "professional"
+}
 /** Relationships to other compositions/documents */
 export interface CompositionRelatesTo extends BackboneElement {
     /** replaces | transforms | signs | appends */
-    code: code;
+    code: `${CompositionCode}`;
     _code?: Element;
     targetIdentifier: Identifier;
-    targetReference: Reference<"Composition">;
+    targetReference: Reference<'Composition'>;
+}
+/** replaces | transforms | signs | appends */
+export declare enum CompositionCode {
+    Appends = "appends",
+    Replaces = "replaces",
+    Signs = "signs",
+    Transforms = "transforms"
+}
+/** preliminary | final | amended | entered-in-error */
+export declare enum CompositionStatus {
+    Amended = "amended",
+    EnteredInError = "entered-in-error",
+    Final = "final",
+    Preliminary = "preliminary"
 }
 /** Composition is broken into sections */
 export interface CompositionSection extends BackboneElement {
@@ -81,7 +117,7 @@ export interface CompositionSection extends BackboneElement {
     /** Nested Section */
     section?: Array<CompositionSection>;
     /** working | snapshot | changes */
-    mode?: code;
+    mode?: `${CompositionSectionMode}`;
     /** Label for section (e.g. for ToC) */
     title?: string;
     /** Why the section is empty */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Composition.js b/vendor/r4/types/hl7-fhir-r4-core/Composition.js
index c8ad2e5..2853304 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Composition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Composition.js
@@ -1,2 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositionStatus = exports.CompositionCode = exports.CompositionMode = exports.CompositionConfidentiality = exports.CompositionSectionMode = void 0;
+/** working | snapshot | changes */
+var CompositionSectionMode;
+(function (CompositionSectionMode) {
+    CompositionSectionMode["Changes"] = "changes";
+    CompositionSectionMode["Snapshot"] = "snapshot";
+    CompositionSectionMode["Working"] = "working";
+})(CompositionSectionMode = exports.CompositionSectionMode || (exports.CompositionSectionMode = {}));
+/** As defined by affinity domain */
+var CompositionConfidentiality;
+(function (CompositionConfidentiality) {
+    CompositionConfidentiality["L"] = "L";
+    CompositionConfidentiality["M"] = "M";
+    CompositionConfidentiality["R"] = "R";
+    CompositionConfidentiality["V"] = "V";
+    CompositionConfidentiality["U"] = "U";
+    CompositionConfidentiality["N"] = "N";
+})(CompositionConfidentiality = exports.CompositionConfidentiality || (exports.CompositionConfidentiality = {}));
+/** personal | professional | legal | official */
+var CompositionMode;
+(function (CompositionMode) {
+    CompositionMode["Legal"] = "legal";
+    CompositionMode["Official"] = "official";
+    CompositionMode["Personal"] = "personal";
+    CompositionMode["Professional"] = "professional";
+})(CompositionMode = exports.CompositionMode || (exports.CompositionMode = {}));
+/** replaces | transforms | signs | appends */
+var CompositionCode;
+(function (CompositionCode) {
+    CompositionCode["Appends"] = "appends";
+    CompositionCode["Replaces"] = "replaces";
+    CompositionCode["Signs"] = "signs";
+    CompositionCode["Transforms"] = "transforms";
+})(CompositionCode = exports.CompositionCode || (exports.CompositionCode = {}));
+/** preliminary | final | amended | entered-in-error */
+var CompositionStatus;
+(function (CompositionStatus) {
+    CompositionStatus["Amended"] = "amended";
+    CompositionStatus["EnteredInError"] = "entered-in-error";
+    CompositionStatus["Final"] = "final";
+    CompositionStatus["Preliminary"] = "preliminary";
+})(CompositionStatus = exports.CompositionStatus || (exports.CompositionStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ConceptMap.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ConceptMap.d.ts
index 6fb4cd7..3b09933 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ConceptMap.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ConceptMap.d.ts
@@ -14,6 +14,7 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A statement of relationships from one set of concepts to one or more other concepts - either concepts in code systems, or data element/data element concepts, or classes in class models. */
 export interface ConceptMap extends DomainResource {
+    resourceType: 'ConceptMap';
     /** Natural language description of the concept map */
     description?: markdown;
     sourceCanonical?: canonical;
@@ -49,7 +50,7 @@ export interface ConceptMap extends DomainResource {
     _purpose?: Element;
     targetCanonical?: canonical;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${ConceptMapStatus}`;
     sourceUri?: uri;
     _name?: Element;
     /** Canonical identifier for this concept map, represented as a URI (globally unique) */
@@ -66,10 +67,16 @@ export interface ConceptMap extends DomainResource {
     contact?: Array<ContactDetail>;
     _url?: Element;
 }
+/** provided | fixed | other-map */
+export declare enum ConceptMapMode {
+    Fixed = "fixed",
+    OtherMap = "other-map",
+    Provided = "provided"
+}
 /** What to do when there is no mapping for the source concept */
 export interface ConceptMapUnmapped extends BackboneElement {
     /** provided | fixed | other-map */
-    mode: code;
+    mode: `${ConceptMapMode}`;
     _mode?: Element;
     /** Fixed code when mode = fixed */
     code?: code;
@@ -81,6 +88,19 @@ export interface ConceptMapUnmapped extends BackboneElement {
     url?: canonical;
     _url?: Element;
 }
+/** relatedto | equivalent | equal | wider | subsumes | narrower | specializes | inexact | unmatched | disjoint */
+export declare enum ConceptMapEquivalence {
+    Disjoint = "disjoint",
+    Equal = "equal",
+    Specializes = "specializes",
+    Subsumes = "subsumes",
+    Inexact = "inexact",
+    Relatedto = "relatedto",
+    Wider = "wider",
+    Equivalent = "equivalent",
+    Unmatched = "unmatched",
+    Narrower = "narrower"
+}
 /** Concept in target system for element */
 export interface ConceptMapTarget extends BackboneElement {
     _code?: Element;
@@ -95,7 +115,7 @@ export interface ConceptMapTarget extends BackboneElement {
     /** Display for the code */
     display?: string;
     /** relatedto | equivalent | equal | wider | subsumes | narrower | specializes | inexact | unmatched | disjoint */
-    equivalence: code;
+    equivalence: `${ConceptMapEquivalence}`;
     _comment?: Element;
     _display?: Element;
 }
@@ -129,6 +149,13 @@ export interface ConceptMapGroup extends BackboneElement {
     target?: uri;
     _source?: Element;
 }
+/** draft | active | retired | unknown */
+export declare enum ConceptMapStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
 /** Other elements required for this mapping (from context) */
 export interface ConceptMapGroupElementTargetDependsOn extends BackboneElement {
     /** Reference to property mapping depends on */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ConceptMap.js b/vendor/r4/types/hl7-fhir-r4-core/ConceptMap.js
index c8ad2e5..267c867 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ConceptMap.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ConceptMap.js
@@ -1,2 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConceptMapStatus = exports.ConceptMapEquivalence = exports.ConceptMapMode = void 0;
+/** provided | fixed | other-map */
+var ConceptMapMode;
+(function (ConceptMapMode) {
+    ConceptMapMode["Fixed"] = "fixed";
+    ConceptMapMode["OtherMap"] = "other-map";
+    ConceptMapMode["Provided"] = "provided";
+})(ConceptMapMode = exports.ConceptMapMode || (exports.ConceptMapMode = {}));
+/** relatedto | equivalent | equal | wider | subsumes | narrower | specializes | inexact | unmatched | disjoint */
+var ConceptMapEquivalence;
+(function (ConceptMapEquivalence) {
+    ConceptMapEquivalence["Disjoint"] = "disjoint";
+    ConceptMapEquivalence["Equal"] = "equal";
+    ConceptMapEquivalence["Specializes"] = "specializes";
+    ConceptMapEquivalence["Subsumes"] = "subsumes";
+    ConceptMapEquivalence["Inexact"] = "inexact";
+    ConceptMapEquivalence["Relatedto"] = "relatedto";
+    ConceptMapEquivalence["Wider"] = "wider";
+    ConceptMapEquivalence["Equivalent"] = "equivalent";
+    ConceptMapEquivalence["Unmatched"] = "unmatched";
+    ConceptMapEquivalence["Narrower"] = "narrower";
+})(ConceptMapEquivalence = exports.ConceptMapEquivalence || (exports.ConceptMapEquivalence = {}));
+/** draft | active | retired | unknown */
+var ConceptMapStatus;
+(function (ConceptMapStatus) {
+    ConceptMapStatus["Active"] = "active";
+    ConceptMapStatus["Draft"] = "draft";
+    ConceptMapStatus["Retired"] = "retired";
+    ConceptMapStatus["Unknown"] = "unknown";
+})(ConceptMapStatus = exports.ConceptMapStatus || (exports.ConceptMapStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Condition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Condition.d.ts
index 13a4efc..60844d0 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Condition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Condition.d.ts
@@ -13,11 +13,12 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern. */
 export interface Condition extends DomainResource {
+    resourceType: 'Condition';
     /** problem-list-item | encounter-diagnosis */
     category?: Array<CodeableConcept>;
     _onsetString?: Element;
     /** active | recurrence | relapse | inactive | remission | resolved */
-    clinicalStatus?: CodeableConcept;
+    clinicalStatus?: `${ConditionClinicalStatus}`;
     abatementAge?: Age;
     onsetRange?: Range;
     onsetAge?: Age;
@@ -25,13 +26,13 @@ export interface Condition extends DomainResource {
     stage?: Array<ConditionStage>;
     _abatementString?: Element;
     /** Encounter created as part of */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     /** Supporting evidence */
     evidence?: Array<ConditionEvidence>;
     onsetPeriod?: Period;
     abatementPeriod?: Period;
     /** Person who asserts this condition */
-    asserter?: Reference<"Patient" | "PractitionerRole" | "Practitioner" | "RelatedPerson">;
+    asserter?: Reference<'Patient' | 'PractitionerRole' | 'Practitioner' | 'RelatedPerson'>;
     /** Additional information about the Condition */
     note?: Array<Annotation>;
     abatementString?: string;
@@ -42,7 +43,7 @@ export interface Condition extends DomainResource {
     _recordedDate?: Element;
     onsetString?: string;
     /** Who recorded the condition */
-    recorder?: Reference<"Patient" | "PractitionerRole" | "Practitioner" | "RelatedPerson">;
+    recorder?: Reference<'Patient' | 'PractitionerRole' | 'Practitioner' | 'RelatedPerson'>;
     /** Subjective severity of condition */
     severity?: CodeableConcept;
     /** Identification of the condition, problem or diagnosis */
@@ -55,9 +56,19 @@ export interface Condition extends DomainResource {
     abatementDateTime?: dateTime;
     _onsetDateTime?: Element;
     /** unconfirmed | provisional | differential | confirmed | refuted | entered-in-error */
-    verificationStatus?: CodeableConcept;
+    verificationStatus?: `${ConditionVerificationStatus}`;
     /** Who has the condition? */
-    subject: Reference<"Patient" | "Group">;
+    subject: Reference<'Patient' | 'Group'>;
+}
+/** active | recurrence | relapse | inactive | remission | resolved */
+export declare enum ConditionClinicalStatus {
+    Active = "active",
+    Inactive = "inactive",
+    Recurrence = "recurrence",
+    Relapse = "relapse",
+    Remission = "remission",
+    Resolved = "resolved",
+    Unknown = "unknown"
 }
 /** Stage/grade, usually assessed formally */
 export interface ConditionStage extends BackboneElement {
@@ -75,3 +86,12 @@ export interface ConditionEvidence extends BackboneElement {
     /** Supporting information found elsewhere */
     detail?: Array<Reference>;
 }
+/** unconfirmed | provisional | differential | confirmed | refuted | entered-in-error */
+export declare enum ConditionVerificationStatus {
+    Confirmed = "confirmed",
+    Differential = "differential",
+    EnteredInError = "entered-in-error",
+    Provisional = "provisional",
+    Refuted = "refuted",
+    Unconfirmed = "unconfirmed"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Condition.js b/vendor/r4/types/hl7-fhir-r4-core/Condition.js
index c8ad2e5..bfca4f8 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Condition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Condition.js
@@ -1,2 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionVerificationStatus = exports.ConditionClinicalStatus = void 0;
+/** active | recurrence | relapse | inactive | remission | resolved */
+var ConditionClinicalStatus;
+(function (ConditionClinicalStatus) {
+    ConditionClinicalStatus["Active"] = "active";
+    ConditionClinicalStatus["Inactive"] = "inactive";
+    ConditionClinicalStatus["Recurrence"] = "recurrence";
+    ConditionClinicalStatus["Relapse"] = "relapse";
+    ConditionClinicalStatus["Remission"] = "remission";
+    ConditionClinicalStatus["Resolved"] = "resolved";
+    ConditionClinicalStatus["Unknown"] = "unknown";
+})(ConditionClinicalStatus = exports.ConditionClinicalStatus || (exports.ConditionClinicalStatus = {}));
+/** unconfirmed | provisional | differential | confirmed | refuted | entered-in-error */
+var ConditionVerificationStatus;
+(function (ConditionVerificationStatus) {
+    ConditionVerificationStatus["Confirmed"] = "confirmed";
+    ConditionVerificationStatus["Differential"] = "differential";
+    ConditionVerificationStatus["EnteredInError"] = "entered-in-error";
+    ConditionVerificationStatus["Provisional"] = "provisional";
+    ConditionVerificationStatus["Refuted"] = "refuted";
+    ConditionVerificationStatus["Unconfirmed"] = "unconfirmed";
+})(ConditionVerificationStatus = exports.ConditionVerificationStatus || (exports.ConditionVerificationStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Consent.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Consent.d.ts
index f86032c..45a0561 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Consent.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Consent.d.ts
@@ -9,13 +9,13 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A record of a healthcare consumer’s  choices, which permits or denies identified recipient(s) or recipient role(s) to perform one or more actions within a given policy context, for specific purposes and periods of time. */
 export interface Consent extends DomainResource {
+    resourceType: 'Consent';
     /** Who the consent applies to */
-    patient?: Reference<"Patient">;
+    patient?: Reference<'Patient'>;
     /** Classification of the consent statement - for indexing/retrieval */
     category: Array<CodeableConcept>;
     provision?: ConsentProvision;
@@ -30,11 +30,11 @@ export interface Consent extends DomainResource {
     scope: CodeableConcept;
     /** Policies covered by this consent */
     policy?: Array<ConsentPolicy>;
-    sourceReference?: Reference<"QuestionnaireResponse" | "Contract" | "DocumentReference" | "Consent">;
+    sourceReference?: Reference<'QuestionnaireResponse' | 'Contract' | 'DocumentReference' | 'Consent'>;
     /** When this Consent was created or indexed */
     dateTime?: dateTime;
     /** draft | proposed | active | rejected | inactive | entered-in-error */
-    status: code;
+    status: `${ConsentStatus}`;
     /** Regulation that this consents to */
     policyRule?: CodeableConcept;
     /** Identifier for this record (external references) */
@@ -48,7 +48,7 @@ export interface ConsentVerification extends BackboneElement {
     verified: boolean;
     _verified?: Element;
     /** Person who verified */
-    verifiedWith?: Reference<"Patient" | "RelatedPerson">;
+    verifiedWith?: Reference<'Patient' | 'RelatedPerson'>;
     /** When consent verified */
     verificationDate?: dateTime;
     _verificationDate?: Element;
@@ -62,17 +62,38 @@ export interface ConsentPolicy extends BackboneElement {
     uri?: uri;
     _uri?: Element;
 }
+/** draft | proposed | active | rejected | inactive | entered-in-error */
+export declare enum ConsentStatus {
+    Active = "active",
+    Draft = "draft",
+    EnteredInError = "entered-in-error",
+    Inactive = "inactive",
+    Proposed = "proposed",
+    Rejected = "rejected"
+}
+/** deny | permit */
+export declare enum ConsentProvisionType {
+    Deny = "deny",
+    Permit = "permit"
+}
 /** Who|what controlled by this rule (or group, by role) */
 export interface ConsentProvisionActor extends BackboneElement {
     /** How the actor is involved */
     role: CodeableConcept;
     /** Resource for the actor (or group, by role) */
-    reference: Reference<"CareTeam" | "Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson" | "Group">;
+    reference: Reference<'CareTeam' | 'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson' | 'Group'>;
+}
+/** instance | related | dependents | authoredby */
+export declare enum ConsentProvisionMeaning {
+    Authoredby = "authoredby",
+    Dependents = "dependents",
+    Instance = "instance",
+    Related = "related"
 }
 /** Data controlled by this rule */
 export interface ConsentProvisionData extends BackboneElement {
     /** instance | related | dependents | authoredby */
-    meaning: code;
+    meaning: `${ConsentProvisionMeaning}`;
     _meaning?: Element;
     /** The actual data reference */
     reference: Reference;
@@ -87,7 +108,7 @@ export interface ConsentProvision extends BackboneElement {
     dataPeriod?: Period;
     _type?: Element;
     /** deny | permit */
-    type?: code;
+    type?: `${ConsentProvisionType}`;
     /** e.g. Resource Type, Profile, CDA, etc. */
     class?: Array<Coding>;
     /** e.g. LOINC or SNOMED CT code, etc. in the content */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Consent.js b/vendor/r4/types/hl7-fhir-r4-core/Consent.js
index c8ad2e5..090cb6d 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Consent.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Consent.js
@@ -1,2 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsentProvisionMeaning = exports.ConsentProvisionType = exports.ConsentStatus = void 0;
+/** draft | proposed | active | rejected | inactive | entered-in-error */
+var ConsentStatus;
+(function (ConsentStatus) {
+    ConsentStatus["Active"] = "active";
+    ConsentStatus["Draft"] = "draft";
+    ConsentStatus["EnteredInError"] = "entered-in-error";
+    ConsentStatus["Inactive"] = "inactive";
+    ConsentStatus["Proposed"] = "proposed";
+    ConsentStatus["Rejected"] = "rejected";
+})(ConsentStatus = exports.ConsentStatus || (exports.ConsentStatus = {}));
+/** deny | permit */
+var ConsentProvisionType;
+(function (ConsentProvisionType) {
+    ConsentProvisionType["Deny"] = "deny";
+    ConsentProvisionType["Permit"] = "permit";
+})(ConsentProvisionType = exports.ConsentProvisionType || (exports.ConsentProvisionType = {}));
+/** instance | related | dependents | authoredby */
+var ConsentProvisionMeaning;
+(function (ConsentProvisionMeaning) {
+    ConsentProvisionMeaning["Authoredby"] = "authoredby";
+    ConsentProvisionMeaning["Dependents"] = "dependents";
+    ConsentProvisionMeaning["Instance"] = "instance";
+    ConsentProvisionMeaning["Related"] = "related";
+})(ConsentProvisionMeaning = exports.ConsentProvisionMeaning || (exports.ConsentProvisionMeaning = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ContactPoint.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ContactPoint.d.ts
index 2499932..fbfe3e4 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ContactPoint.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ContactPoint.d.ts
@@ -3,13 +3,12 @@ DON'T MODIFY MANUALLY */
 import { positiveInt } from "./positiveInt";
 import { Period } from "./Period";
 import { Element } from "./Element";
-import { code } from "./code";
 /** Base StructureDefinition for ContactPoint Type: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc. */
 export interface ContactPoint extends Element {
     /** phone | fax | email | pager | url | sms | other */
-    system?: code;
+    system?: `${ContactPointSystem}`;
     /** home | work | temp | old | mobile - purpose of this contact point */
-    use?: code;
+    use?: `${ContactPointUse}`;
     /** The actual contact point details */
     value?: string;
     /** Specify preferred order of use (1 = highest) */
@@ -21,3 +20,21 @@ export interface ContactPoint extends Element {
     _use?: Element;
     _rank?: Element;
 }
+/** phone | fax | email | pager | url | sms | other */
+export declare enum ContactPointSystem {
+    Email = "email",
+    Fax = "fax",
+    Other = "other",
+    Pager = "pager",
+    Phone = "phone",
+    Sms = "sms",
+    Url = "url"
+}
+/** home | work | temp | old | mobile - purpose of this contact point */
+export declare enum ContactPointUse {
+    Home = "home",
+    Mobile = "mobile",
+    Old = "old",
+    Temp = "temp",
+    Work = "work"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ContactPoint.js b/vendor/r4/types/hl7-fhir-r4-core/ContactPoint.js
index c8ad2e5..125e9f9 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ContactPoint.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ContactPoint.js
@@ -1,2 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContactPointUse = exports.ContactPointSystem = void 0;
+/** phone | fax | email | pager | url | sms | other */
+var ContactPointSystem;
+(function (ContactPointSystem) {
+    ContactPointSystem["Email"] = "email";
+    ContactPointSystem["Fax"] = "fax";
+    ContactPointSystem["Other"] = "other";
+    ContactPointSystem["Pager"] = "pager";
+    ContactPointSystem["Phone"] = "phone";
+    ContactPointSystem["Sms"] = "sms";
+    ContactPointSystem["Url"] = "url";
+})(ContactPointSystem = exports.ContactPointSystem || (exports.ContactPointSystem = {}));
+/** home | work | temp | old | mobile - purpose of this contact point */
+var ContactPointUse;
+(function (ContactPointUse) {
+    ContactPointUse["Home"] = "home";
+    ContactPointUse["Mobile"] = "mobile";
+    ContactPointUse["Old"] = "old";
+    ContactPointUse["Temp"] = "temp";
+    ContactPointUse["Work"] = "work";
+})(ContactPointUse = exports.ContactPointUse || (exports.ContactPointUse = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Contract.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Contract.d.ts
index aefb395..e5021d7 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Contract.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Contract.d.ts
@@ -20,19 +20,19 @@ import { date } from "./date";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement. */
 export interface Contract extends DomainResource {
+    resourceType: 'Contract';
     _issued?: Element;
     legallyBindingAttachment?: Attachment;
     /** Source Contract Definition */
-    instantiatesCanonical?: Reference<"Contract">;
+    instantiatesCanonical?: Reference<'Contract'>;
     /** External Contract Definition */
     instantiatesUri?: uri;
-    legallyBindingReference?: Reference<"QuestionnaireResponse" | "Composition" | "Contract" | "DocumentReference">;
+    legallyBindingReference?: Reference<'QuestionnaireResponse' | 'Composition' | 'Contract' | 'DocumentReference'>;
     /** Specific Location */
     site?: Array<Reference>;
     /** Key event in Contract History */
@@ -66,14 +66,14 @@ export interface Contract extends DomainResource {
     /** Contract Signatory */
     signer?: Array<ContractSigner>;
     /** Source of Contract */
-    author?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Practitioner">;
+    author?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Practitioner'>;
     term?: Array<ContractTerm>;
     /** Contract Friendly Language */
     friendly?: Array<ContractFriendly>;
     /** Acronym or short name */
     alias?: Array<string>;
     /** amended | appended | cancelled | disputed | entered-in-error | executable | executed | negotiable | offered | policy | rejected | renewed | revoked | resolved | terminated */
-    status?: code;
+    status?: `${ContractStatus}`;
     /** Subordinate Friendly name */
     subtitle?: string;
     _name?: Element;
@@ -104,7 +104,7 @@ export interface Contract extends DomainResource {
 /** Computable Contract Language */
 export interface ContractRule extends BackboneElement {
     contentAttachment: Attachment;
-    contentReference: Reference<"DocumentReference">;
+    contentReference: Reference<'DocumentReference'>;
 }
 /** Entity of the action */
 export interface ContractTermSubject extends BackboneElement {
@@ -126,12 +126,12 @@ export interface ContractTermContext extends BackboneElement {
 /** Contract Legal Language */
 export interface ContractLegal extends BackboneElement {
     contentAttachment: Attachment;
-    contentReference: Reference<"QuestionnaireResponse" | "Composition" | "DocumentReference">;
+    contentReference: Reference<'QuestionnaireResponse' | 'Composition' | 'DocumentReference'>;
 }
 /** Contract precursor content */
 export interface ContractContentDefinition extends BackboneElement {
     /** Publisher Entity */
-    publisher?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    publisher?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Publication Ownership */
     copyright?: markdown;
     /** Content structure and use */
@@ -139,7 +139,7 @@ export interface ContractContentDefinition extends BackboneElement {
     _publicationStatus?: Element;
     _publicationDate?: Element;
     /** amended | appended | cancelled | disputed | entered-in-error | executable | executed | negotiable | offered | policy | rejected | renewed | revoked | resolved | terminated */
-    publicationStatus: code;
+    publicationStatus: `${ContractPublicationStatus}`;
     _copyright?: Element;
     /** Detailed Content Type Definition */
     subType?: CodeableConcept;
@@ -180,7 +180,7 @@ export interface ContractSigner extends BackboneElement {
     /** Contract Signatory Role */
     type: Coding;
     /** Contract Signatory Party */
-    party: Reference<"Patient" | "PractitionerRole" | "Organization" | "Practitioner" | "RelatedPerson">;
+    party: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Practitioner' | 'RelatedPerson'>;
     /** Contract Documentation Signature */
     signature: Array<Signature>;
 }
@@ -207,6 +207,24 @@ export interface ContractTermOfferAnswer extends BackboneElement {
     valueAttachment: Attachment;
     _valueInteger: Element;
 }
+/** amended | appended | cancelled | disputed | entered-in-error | executable | executed | negotiable | offered | policy | rejected | renewed | revoked | resolved | terminated */
+export declare enum ContractPublicationStatus {
+    Cancelled = "cancelled",
+    Amended = "amended",
+    Rejected = "rejected",
+    Negotiable = "negotiable",
+    Executed = "executed",
+    Executable = "executable",
+    Appended = "appended",
+    Offered = "offered",
+    Resolved = "resolved",
+    EnteredInError = "entered-in-error",
+    Policy = "policy",
+    Terminated = "terminated",
+    Revoked = "revoked",
+    Renewed = "renewed",
+    Disputed = "disputed"
+}
 /** Protection for the Term */
 export interface ContractTermSecurityLabel extends BackboneElement {
     /** Link to Security Labels */
@@ -298,14 +316,14 @@ export interface ContractTermValuedItem extends BackboneElement {
     payment?: string;
     _factor?: Element;
     /** Who will receive payment */
-    recipient?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Practitioner" | "RelatedPerson">;
+    recipient?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Practitioner' | 'RelatedPerson'>;
     /** Total Contract Valued Item Value */
     net?: Money;
     /** Contract Valued Item Difficulty Scaling Factor */
     points?: decimal;
     _linkId?: Array<Element>;
     /** Who will make payment */
-    responsible?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Practitioner" | "RelatedPerson">;
+    responsible?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Practitioner' | 'RelatedPerson'>;
     _points?: Element;
     /** Security Labels that define affected terms */
     securityLabelNumber?: Array<unsignedInt>;
@@ -326,10 +344,28 @@ export interface ContractTermValuedItem extends BackboneElement {
     unitPrice?: Money;
     entityReference?: Reference;
 }
+/** amended | appended | cancelled | disputed | entered-in-error | executable | executed | negotiable | offered | policy | rejected | renewed | revoked | resolved | terminated */
+export declare enum ContractStatus {
+    Cancelled = "cancelled",
+    Amended = "amended",
+    Rejected = "rejected",
+    Negotiable = "negotiable",
+    Executed = "executed",
+    Executable = "executable",
+    Appended = "appended",
+    Offered = "offered",
+    Resolved = "resolved",
+    EnteredInError = "entered-in-error",
+    Policy = "policy",
+    Terminated = "terminated",
+    Revoked = "revoked",
+    Renewed = "renewed",
+    Disputed = "disputed"
+}
 /** Contract Friendly Language */
 export interface ContractFriendly extends BackboneElement {
     contentAttachment: Attachment;
-    contentReference: Reference<"QuestionnaireResponse" | "Composition" | "DocumentReference">;
+    contentReference: Reference<'QuestionnaireResponse' | 'Composition' | 'DocumentReference'>;
 }
 /** Entity being ascribed responsibility */
 export interface ContractTermAction extends BackboneElement {
@@ -370,7 +406,7 @@ export interface ContractTermAction extends BackboneElement {
     doNotPerform?: boolean;
     _reason?: Array<Element>;
     /** Episode associated with action */
-    context?: Reference<"EpisodeOfCare" | "Encounter">;
+    context?: Reference<'EpisodeOfCare' | 'Encounter'>;
     /** Purpose for the Contract Term Action */
     intent: CodeableConcept;
     /** Pointer to specific item */
@@ -379,7 +415,7 @@ export interface ContractTermAction extends BackboneElement {
     /** Entity of the action */
     subject?: Array<ContractTermSubject>;
     /** Actor that wil execute (or not) the action */
-    performer?: Reference<"CareTeam" | "Patient" | "PractitionerRole" | "Organization" | "Device" | "Location" | "Substance" | "Practitioner" | "RelatedPerson">;
+    performer?: Reference<'CareTeam' | 'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Location' | 'Substance' | 'Practitioner' | 'RelatedPerson'>;
     /** Pointer to specific item */
     contextLinkId?: Array<string>;
     /** Why is action (not) needed? */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Contract.js b/vendor/r4/types/hl7-fhir-r4-core/Contract.js
index c8ad2e5..f79e12c 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Contract.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Contract.js
@@ -1,2 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractStatus = exports.ContractPublicationStatus = void 0;
+/** amended | appended | cancelled | disputed | entered-in-error | executable | executed | negotiable | offered | policy | rejected | renewed | revoked | resolved | terminated */
+var ContractPublicationStatus;
+(function (ContractPublicationStatus) {
+    ContractPublicationStatus["Cancelled"] = "cancelled";
+    ContractPublicationStatus["Amended"] = "amended";
+    ContractPublicationStatus["Rejected"] = "rejected";
+    ContractPublicationStatus["Negotiable"] = "negotiable";
+    ContractPublicationStatus["Executed"] = "executed";
+    ContractPublicationStatus["Executable"] = "executable";
+    ContractPublicationStatus["Appended"] = "appended";
+    ContractPublicationStatus["Offered"] = "offered";
+    ContractPublicationStatus["Resolved"] = "resolved";
+    ContractPublicationStatus["EnteredInError"] = "entered-in-error";
+    ContractPublicationStatus["Policy"] = "policy";
+    ContractPublicationStatus["Terminated"] = "terminated";
+    ContractPublicationStatus["Revoked"] = "revoked";
+    ContractPublicationStatus["Renewed"] = "renewed";
+    ContractPublicationStatus["Disputed"] = "disputed";
+})(ContractPublicationStatus = exports.ContractPublicationStatus || (exports.ContractPublicationStatus = {}));
+/** amended | appended | cancelled | disputed | entered-in-error | executable | executed | negotiable | offered | policy | rejected | renewed | revoked | resolved | terminated */
+var ContractStatus;
+(function (ContractStatus) {
+    ContractStatus["Cancelled"] = "cancelled";
+    ContractStatus["Amended"] = "amended";
+    ContractStatus["Rejected"] = "rejected";
+    ContractStatus["Negotiable"] = "negotiable";
+    ContractStatus["Executed"] = "executed";
+    ContractStatus["Executable"] = "executable";
+    ContractStatus["Appended"] = "appended";
+    ContractStatus["Offered"] = "offered";
+    ContractStatus["Resolved"] = "resolved";
+    ContractStatus["EnteredInError"] = "entered-in-error";
+    ContractStatus["Policy"] = "policy";
+    ContractStatus["Terminated"] = "terminated";
+    ContractStatus["Revoked"] = "revoked";
+    ContractStatus["Renewed"] = "renewed";
+    ContractStatus["Disputed"] = "disputed";
+})(ContractStatus = exports.ContractStatus || (exports.ContractStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Contributor.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Contributor.d.ts
index 080fb90..162005e 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Contributor.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Contributor.d.ts
@@ -2,11 +2,10 @@
 DON'T MODIFY MANUALLY */
 import { ContactDetail } from "./ContactDetail";
 import { Element } from "./Element";
-import { code } from "./code";
 /** Base StructureDefinition for Contributor Type: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers. */
 export interface Contributor extends Element {
     /** author | editor | reviewer | endorser */
-    type: code;
+    type: `${ContributorType}`;
     _type?: Element;
     /** Who contributed the content */
     name: string;
@@ -14,3 +13,10 @@ export interface Contributor extends Element {
     /** Contact details of the contributor */
     contact?: Array<ContactDetail>;
 }
+/** author | editor | reviewer | endorser */
+export declare enum ContributorType {
+    Author = "author",
+    Editor = "editor",
+    Endorser = "endorser",
+    Reviewer = "reviewer"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Contributor.js b/vendor/r4/types/hl7-fhir-r4-core/Contributor.js
index c8ad2e5..985f4e1 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Contributor.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Contributor.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContributorType = void 0;
+/** author | editor | reviewer | endorser */
+var ContributorType;
+(function (ContributorType) {
+    ContributorType["Author"] = "author";
+    ContributorType["Editor"] = "editor";
+    ContributorType["Endorser"] = "endorser";
+    ContributorType["Reviewer"] = "reviewer";
+})(ContributorType = exports.ContributorType || (exports.ContributorType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Coverage.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Coverage.d.ts
index 2e22be9..8235f2f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Coverage.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Coverage.d.ts
@@ -8,16 +8,16 @@ import { DomainResource } from "./DomainResource";
 import { Money } from "./Money";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment. */
 export interface Coverage extends DomainResource {
+    resourceType: 'Coverage';
     _order?: Element;
     /** Owner of the policy */
-    policyHolder?: Reference<"Patient" | "Organization" | "RelatedPerson">;
+    policyHolder?: Reference<'Patient' | 'Organization' | 'RelatedPerson'>;
     /** Plan beneficiary */
-    beneficiary: Reference<"Patient">;
+    beneficiary: Reference<'Patient'>;
     /** Contract details */
     contract?: Array<Reference>;
     _status?: Element;
@@ -30,11 +30,11 @@ export interface Coverage extends DomainResource {
     /** Reimbursement to insurer */
     subrogation?: boolean;
     /** Subscriber to the policy */
-    subscriber?: Reference<"Patient" | "RelatedPerson">;
+    subscriber?: Reference<'Patient' | 'RelatedPerson'>;
     /** Issuer of the policy */
     payor: Array<Reference>;
     /** active | cancelled | draft | entered-in-error */
-    status: code;
+    status: `${CoverageStatus}`;
     /** Additional coverage classifications */
     class?: Array<CoverageClass>;
     /** Business Identifier for the coverage */
@@ -70,6 +70,13 @@ export interface CoverageCostToBeneficiary extends BackboneElement {
     /** Exceptions for patient payments */
     exception?: Array<CoverageException>;
 }
+/** active | cancelled | draft | entered-in-error */
+export declare enum CoverageStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    EnteredInError = "entered-in-error"
+}
 /** Additional coverage classifications */
 export interface CoverageClass extends BackboneElement {
     /** Type of class such as 'group' or 'plan' */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Coverage.js b/vendor/r4/types/hl7-fhir-r4-core/Coverage.js
index c8ad2e5..7271e7f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Coverage.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Coverage.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoverageStatus = void 0;
+/** active | cancelled | draft | entered-in-error */
+var CoverageStatus;
+(function (CoverageStatus) {
+    CoverageStatus["Active"] = "active";
+    CoverageStatus["Cancelled"] = "cancelled";
+    CoverageStatus["Draft"] = "draft";
+    CoverageStatus["EnteredInError"] = "entered-in-error";
+})(CoverageStatus = exports.CoverageStatus || (exports.CoverageStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityRequest.d.ts b/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityRequest.d.ts
index ba668b1..04a4993 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityRequest.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityRequest.d.ts
@@ -15,15 +15,16 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** The CoverageEligibilityRequest provides patient and insurance coverage information to an insurer for them to respond, in the form of an CoverageEligibilityResponse, with information regarding whether the stated coverage is valid and in-force and optionally to provide the insurance details of the policy. */
 export interface CoverageEligibilityRequest extends DomainResource {
+    resourceType: 'CoverageEligibilityRequest';
     _created?: Element;
     /** Intended recipient of products and services */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** Patient insurance information */
     insurance?: Array<CoverageEligibilityRequestInsurance>;
     /** Servicing facility */
-    facility?: Reference<"Location">;
+    facility?: Reference<'Location'>;
     /** Author */
-    enterer?: Reference<"PractitionerRole" | "Practitioner">;
+    enterer?: Reference<'PractitionerRole' | 'Practitioner'>;
     /** Supporting information */
     supportingInfo?: Array<CoverageEligibilityRequestSupportingInfo>;
     /** auth-requirements | benefits | discovery | validation */
@@ -35,17 +36,17 @@ export interface CoverageEligibilityRequest extends DomainResource {
     created: dateTime;
     _purpose?: Array<Element>;
     /** Coverage issuer */
-    insurer: Reference<"Organization">;
+    insurer: Reference<'Organization'>;
     /** Desired processing priority */
     priority?: CodeableConcept;
     /** active | cancelled | draft | entered-in-error */
-    status: code;
+    status: `${CoverageEligibilityRequestStatus}`;
     servicedDate?: date;
     /** Business Identifier for coverage eligiblity request */
     identifier?: Array<Identifier>;
     _servicedDate?: Element;
     /** Party responsible for the request */
-    provider?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    provider?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     servicedPeriod?: Period;
 }
 /** Patient insurance information */
@@ -54,7 +55,7 @@ export interface CoverageEligibilityRequestInsurance extends BackboneElement {
     focal?: boolean;
     _focal?: Element;
     /** Insurance information */
-    coverage: Reference<"Coverage">;
+    coverage: Reference<'Coverage'>;
     /** Additional provider contract number */
     businessArrangement?: string;
     _businessArrangement?: Element;
@@ -73,14 +74,14 @@ export interface CoverageEligibilityRequestSupportingInfo extends BackboneElemen
 /** Applicable diagnosis */
 export interface CoverageEligibilityRequestDiagnosis extends BackboneElement {
     diagnosisCodeableConcept?: CodeableConcept;
-    diagnosisReference?: Reference<"Condition">;
+    diagnosisReference?: Reference<'Condition'>;
 }
 /** Item to be evaluated for eligibiity */
 export interface CoverageEligibilityRequestItem extends BackboneElement {
     /** Benefit classification */
     category?: CodeableConcept;
     /** Servicing facility */
-    facility?: Reference<"Organization" | "Location">;
+    facility?: Reference<'Organization' | 'Location'>;
     /** Applicable diagnosis */
     diagnosis?: Array<CoverageEligibilityRequestDiagnosis>;
     /** Product or service billing modifiers */
@@ -91,7 +92,7 @@ export interface CoverageEligibilityRequestItem extends BackboneElement {
     /** Count of products or services */
     quantity?: SimpleQuantity;
     /** Perfoming practitioner */
-    provider?: Reference<"PractitionerRole" | "Practitioner">;
+    provider?: Reference<'PractitionerRole' | 'Practitioner'>;
     /** Applicable exception or supporting information */
     supportingInfoSequence?: Array<positiveInt>;
     /** Fee, charge or cost per item */
@@ -99,3 +100,10 @@ export interface CoverageEligibilityRequestItem extends BackboneElement {
     /** Product or service details */
     detail?: Array<Reference>;
 }
+/** active | cancelled | draft | entered-in-error */
+export declare enum CoverageEligibilityRequestStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    EnteredInError = "entered-in-error"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityRequest.js b/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityRequest.js
index c8ad2e5..f2fa97a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityRequest.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityRequest.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoverageEligibilityRequestStatus = void 0;
+/** active | cancelled | draft | entered-in-error */
+var CoverageEligibilityRequestStatus;
+(function (CoverageEligibilityRequestStatus) {
+    CoverageEligibilityRequestStatus["Active"] = "active";
+    CoverageEligibilityRequestStatus["Cancelled"] = "cancelled";
+    CoverageEligibilityRequestStatus["Draft"] = "draft";
+    CoverageEligibilityRequestStatus["EnteredInError"] = "entered-in-error";
+})(CoverageEligibilityRequestStatus = exports.CoverageEligibilityRequestStatus || (exports.CoverageEligibilityRequestStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityResponse.d.ts b/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityResponse.d.ts
index 1350743..7bd2247 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityResponse.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityResponse.d.ts
@@ -15,15 +15,16 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource. */
 export interface CoverageEligibilityResponse extends DomainResource {
+    resourceType: 'CoverageEligibilityResponse';
     _created?: Element;
     /** Intended recipient of products and services */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** Party responsible for the request */
-    requestor?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    requestor?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Patient insurance information */
     insurance?: Array<CoverageEligibilityResponseInsurance>;
     /** Eligibility request reference */
-    request: Reference<"CoverageEligibilityRequest">;
+    request: Reference<'CoverageEligibilityRequest'>;
     /** Preauthorization reference */
     preAuthRef?: string;
     _disposition?: Element;
@@ -33,15 +34,15 @@ export interface CoverageEligibilityResponse extends DomainResource {
     /** Response creation date */
     created: dateTime;
     /** queued | complete | error | partial */
-    outcome: code;
+    outcome: `${CoverageEligibilityResponseOutcome}`;
     _outcome?: Element;
     /** Disposition Message */
     disposition?: string;
     _purpose?: Array<Element>;
     /** Coverage issuer */
-    insurer: Reference<"Organization">;
+    insurer: Reference<'Organization'>;
     /** active | cancelled | draft | entered-in-error */
-    status: code;
+    status: `${CoverageEligibilityResponseStatus}`;
     servicedDate?: date;
     /** Business Identifier for coverage eligiblity request */
     identifier?: Array<Identifier>;
@@ -101,13 +102,13 @@ export interface CoverageEligibilityResponseItem extends BackboneElement {
     network?: CodeableConcept;
     _authorizationRequired?: Element;
     /** Performing practitioner */
-    provider?: Reference<"PractitionerRole" | "Practitioner">;
+    provider?: Reference<'PractitionerRole' | 'Practitioner'>;
     _excluded?: Element;
 }
 /** Patient insurance information */
 export interface CoverageEligibilityResponseInsurance extends BackboneElement {
     /** Insurance information */
-    coverage: Reference<"Coverage">;
+    coverage: Reference<'Coverage'>;
     /** Coverage inforce indicator */
     inforce?: boolean;
     _inforce?: Element;
@@ -116,6 +117,20 @@ export interface CoverageEligibilityResponseInsurance extends BackboneElement {
     /** Benefits and authorization details */
     item?: Array<CoverageEligibilityResponseItem>;
 }
+/** queued | complete | error | partial */
+export declare enum CoverageEligibilityResponseOutcome {
+    Complete = "complete",
+    Error = "error",
+    Partial = "partial",
+    Queued = "queued"
+}
+/** active | cancelled | draft | entered-in-error */
+export declare enum CoverageEligibilityResponseStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    EnteredInError = "entered-in-error"
+}
 /** Processing errors */
 export interface CoverageEligibilityResponseError extends BackboneElement {
     /** Error code detailing processing issues */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityResponse.js b/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityResponse.js
index c8ad2e5..1b8d5ad 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityResponse.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/CoverageEligibilityResponse.js
@@ -1,2 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoverageEligibilityResponseStatus = exports.CoverageEligibilityResponseOutcome = void 0;
+/** queued | complete | error | partial */
+var CoverageEligibilityResponseOutcome;
+(function (CoverageEligibilityResponseOutcome) {
+    CoverageEligibilityResponseOutcome["Complete"] = "complete";
+    CoverageEligibilityResponseOutcome["Error"] = "error";
+    CoverageEligibilityResponseOutcome["Partial"] = "partial";
+    CoverageEligibilityResponseOutcome["Queued"] = "queued";
+})(CoverageEligibilityResponseOutcome = exports.CoverageEligibilityResponseOutcome || (exports.CoverageEligibilityResponseOutcome = {}));
+/** active | cancelled | draft | entered-in-error */
+var CoverageEligibilityResponseStatus;
+(function (CoverageEligibilityResponseStatus) {
+    CoverageEligibilityResponseStatus["Active"] = "active";
+    CoverageEligibilityResponseStatus["Cancelled"] = "cancelled";
+    CoverageEligibilityResponseStatus["Draft"] = "draft";
+    CoverageEligibilityResponseStatus["EnteredInError"] = "entered-in-error";
+})(CoverageEligibilityResponseStatus = exports.CoverageEligibilityResponseStatus || (exports.CoverageEligibilityResponseStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DataRequirement.d.ts b/vendor/r4/types/hl7-fhir-r4-core/DataRequirement.d.ts
index f339da1..080d47b 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DataRequirement.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/DataRequirement.d.ts
@@ -9,7 +9,6 @@ import { canonical } from "./canonical";
 import { Duration } from "./Duration";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 /** Base StructureDefinition for DataRequirement Type: Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data. */
 export interface DataRequirement extends Element {
     /** Number of results */
@@ -19,13 +18,13 @@ export interface DataRequirement extends Element {
     subjectCodeableConcept?: CodeableConcept;
     _type?: Element;
     /** The type of the required data */
-    type: code;
+    type: `${DataRequirementType}`;
     /** Indicates specific structure elements that are referenced by the knowledge module */
     mustSupport?: Array<string>;
     _profile?: Array<Element>;
     /** What codes are expected */
     codeFilter?: Array<DataRequirementCodeFilter>;
-    subjectReference?: Reference<"Group">;
+    subjectReference?: Reference<'Group'>;
     /** What dates/date ranges are expected */
     dateFilter?: Array<DataRequirementDateFilter>;
     /** Order of the results */
@@ -33,6 +32,222 @@ export interface DataRequirement extends Element {
     /** The profile of the required data */
     profile?: Array<canonical>;
 }
+/** The type of the required data */
+export declare enum DataRequirementType {
+    ImmunizationEvaluation = "ImmunizationEvaluation",
+    Appointment = "Appointment",
+    StructureMap = "StructureMap",
+    Address = "Address",
+    CareTeam = "CareTeam",
+    UsageContext = "UsageContext",
+    Linkage = "Linkage",
+    Annotation = "Annotation",
+    Age = "Age",
+    Attachment = "Attachment",
+    Communication = "Communication",
+    MedicationDispense = "MedicationDispense",
+    ImagingStudy = "ImagingStudy",
+    ChargeItem = "ChargeItem",
+    Period = "Period",
+    AdverseEvent = "AdverseEvent",
+    ContactDetail = "ContactDetail",
+    DataRequirement = "DataRequirement",
+    Media = "Media",
+    CodeableConcept = "CodeableConcept",
+    Uri = "uri",
+    SubstancePolymer = "SubstancePolymer",
+    QuestionnaireResponse = "QuestionnaireResponse",
+    Coverage = "Coverage",
+    Procedure = "Procedure",
+    AuditEvent = "AuditEvent",
+    PaymentReconciliation = "PaymentReconciliation",
+    MedicinalProductManufactured = "MedicinalProductManufactured",
+    CompartmentDefinition = "CompartmentDefinition",
+    Type = "Type",
+    Organization = "Organization",
+    ExplanationOfBenefit = "ExplanationOfBenefit",
+    Composition = "Composition",
+    SimpleQuantity = "SimpleQuantity",
+    CoverageEligibilityResponse = "CoverageEligibilityResponse",
+    DocumentReference = "DocumentReference",
+    EventDefinition = "EventDefinition",
+    SubstanceProtein = "SubstanceProtein",
+    TerminologyCapabilities = "TerminologyCapabilities",
+    Encounter = "Encounter",
+    ImplementationGuide = "ImplementationGuide",
+    EvidenceVariable = "EvidenceVariable",
+    ObservationDefinition = "ObservationDefinition",
+    DiagnosticReport = "DiagnosticReport",
+    ExampleScenario = "ExampleScenario",
+    ResearchDefinition = "ResearchDefinition",
+    Parameters = "Parameters",
+    Instant = "instant",
+    SearchParameter = "SearchParameter",
+    MedicinalProductInteraction = "MedicinalProductInteraction",
+    CodeSystem = "CodeSystem",
+    MessageDefinition = "MessageDefinition",
+    NutritionOrder = "NutritionOrder",
+    VerificationResult = "VerificationResult",
+    MedicationAdministration = "MedicationAdministration",
+    CatalogEntry = "CatalogEntry",
+    Flag = "Flag",
+    DeviceUseStatement = "DeviceUseStatement",
+    TriggerDefinition = "TriggerDefinition",
+    Contract = "Contract",
+    Invoice = "Invoice",
+    MarketingStatus = "MarketingStatus",
+    Count = "Count",
+    PaymentNotice = "PaymentNotice",
+    Location = "Location",
+    Claim = "Claim",
+    Specimen = "Specimen",
+    MedicationStatement = "MedicationStatement",
+    EnrollmentResponse = "EnrollmentResponse",
+    Uuid = "uuid",
+    Evidence = "Evidence",
+    Bundle = "Bundle",
+    ResearchElementDefinition = "ResearchElementDefinition",
+    Expression = "Expression",
+    Coding = "Coding",
+    BodyStructure = "BodyStructure",
+    MedicinalProduct = "MedicinalProduct",
+    Canonical = "canonical",
+    ResearchStudy = "ResearchStudy",
+    Dosage = "Dosage",
+    AppointmentResponse = "AppointmentResponse",
+    MedicinalProductIndication = "MedicinalProductIndication",
+    Measure = "Measure",
+    Person = "Person",
+    InsurancePlan = "InsurancePlan",
+    Date = "date",
+    Patient = "Patient",
+    EffectEvidenceSynthesis = "EffectEvidenceSynthesis",
+    ResearchSubject = "ResearchSubject",
+    Medication = "Medication",
+    Range = "Range",
+    ConceptMap = "ConceptMap",
+    CoverageEligibilityRequest = "CoverageEligibilityRequest",
+    Population = "Population",
+    SubstanceSourceMaterial = "SubstanceSourceMaterial",
+    VisionPrescription = "VisionPrescription",
+    MolecularSequence = "MolecularSequence",
+    MedicinalProductUndesirableEffect = "MedicinalProductUndesirableEffect",
+    OperationOutcome = "OperationOutcome",
+    MessageHeader = "MessageHeader",
+    ContactPoint = "ContactPoint",
+    Signature = "Signature",
+    Decimal = "decimal",
+    Any = "Any",
+    AllergyIntolerance = "AllergyIntolerance",
+    SubstanceReferenceInformation = "SubstanceReferenceInformation",
+    SupplyDelivery = "SupplyDelivery",
+    EpisodeOfCare = "EpisodeOfCare",
+    PractitionerRole = "PractitionerRole",
+    Library = "Library",
+    Practitioner = "Practitioner",
+    Markdown = "markdown",
+    MedicationRequest = "MedicationRequest",
+    ImmunizationRecommendation = "ImmunizationRecommendation",
+    RelatedArtifact = "RelatedArtifact",
+    Timing = "Timing",
+    Immunization = "Immunization",
+    GraphDefinition = "GraphDefinition",
+    Account = "Account",
+    Url = "url",
+    MedicinalProductIngredient = "MedicinalProductIngredient",
+    ProdCharacteristic = "ProdCharacteristic",
+    Meta = "Meta",
+    Quantity = "Quantity",
+    MeasureReport = "MeasureReport",
+    Distance = "Distance",
+    HumanName = "HumanName",
+    DeviceMetric = "DeviceMetric",
+    Duration = "Duration",
+    SubstanceAmount = "SubstanceAmount",
+    Goal = "Goal",
+    MedicationKnowledge = "MedicationKnowledge",
+    Integer = "integer",
+    String = "string",
+    ClaimResponse = "ClaimResponse",
+    DeviceDefinition = "DeviceDefinition",
+    Slot = "Slot",
+    ValueSet = "ValueSet",
+    MedicinalProductAuthorization = "MedicinalProductAuthorization",
+    StructureDefinition = "StructureDefinition",
+    Base64Binary = "base64Binary",
+    MedicinalProductContraindication = "MedicinalProductContraindication",
+    ElementDefinition = "ElementDefinition",
+    DeviceRequest = "DeviceRequest",
+    List = "List",
+    Questionnaire = "Questionnaire",
+    DomainResource = "DomainResource",
+    Endpoint = "Endpoint",
+    NamingSystem = "NamingSystem",
+    MedicinalProductPackaged = "MedicinalProductPackaged",
+    Basic = "Basic",
+    Money = "Money",
+    Binary = "Binary",
+    PlanDefinition = "PlanDefinition",
+    Subscription = "Subscription",
+    SampledData = "SampledData",
+    ProductShelfLife = "ProductShelfLife",
+    RelatedPerson = "RelatedPerson",
+    SubstanceSpecification = "SubstanceSpecification",
+    Ratio = "Ratio",
+    SubstanceNucleicAcid = "SubstanceNucleicAcid",
+    GuidanceResponse = "GuidanceResponse",
+    ClinicalImpression = "ClinicalImpression",
+    OrganizationAffiliation = "OrganizationAffiliation",
+    Resource = "Resource",
+    UnsignedInt = "unsignedInt",
+    Condition = "Condition",
+    Extension = "Extension",
+    CapabilityStatement = "CapabilityStatement",
+    HealthcareService = "HealthcareService",
+    SpecimenDefinition = "SpecimenDefinition",
+    ParameterDefinition = "ParameterDefinition",
+    RiskAssessment = "RiskAssessment",
+    Xhtml = "xhtml",
+    OperationDefinition = "OperationDefinition",
+    ActivityDefinition = "ActivityDefinition",
+    Schedule = "Schedule",
+    BiologicallyDerivedProduct = "BiologicallyDerivedProduct",
+    PositiveInt = "positiveInt",
+    Code = "code",
+    Group = "Group",
+    MedicinalProductPharmaceutical = "MedicinalProductPharmaceutical",
+    FamilyMemberHistory = "FamilyMemberHistory",
+    ServiceRequest = "ServiceRequest",
+    DetectedIssue = "DetectedIssue",
+    Device = "Device",
+    Oid = "oid",
+    RequestGroup = "RequestGroup",
+    TestScript = "TestScript",
+    RiskEvidenceSynthesis = "RiskEvidenceSynthesis",
+    SupplyRequest = "SupplyRequest",
+    Element = "Element",
+    Reference = "Reference",
+    Task = "Task",
+    Identifier = "Identifier",
+    CommunicationRequest = "CommunicationRequest",
+    EnrollmentRequest = "EnrollmentRequest",
+    ChargeItemDefinition = "ChargeItemDefinition",
+    Substance = "Substance",
+    Id = "id",
+    Provenance = "Provenance",
+    Time = "time",
+    Consent = "Consent",
+    BackboneElement = "BackboneElement",
+    CarePlan = "CarePlan",
+    Narrative = "Narrative",
+    MoneyQuantity = "MoneyQuantity",
+    TestReport = "TestReport",
+    Observation = "Observation",
+    DateTime = "dateTime",
+    Boolean = "boolean",
+    DocumentManifest = "DocumentManifest",
+    Contributor = "Contributor"
+}
 /** What codes are expected */
 export interface DataRequirementCodeFilter extends Element {
     /** A code-valued attribute to filter on */
@@ -60,12 +275,17 @@ export interface DataRequirementDateFilter extends Element {
     _valueDateTime?: Element;
     valuePeriod?: Period;
 }
+/** ascending | descending */
+export declare enum DataRequirementDirection {
+    Ascending = "ascending",
+    Descending = "descending"
+}
 /** Order of the results */
 export interface DataRequirementSort extends Element {
     /** The name of the attribute to perform the sort */
     path: string;
     _path?: Element;
     /** ascending | descending */
-    direction: code;
+    direction: `${DataRequirementDirection}`;
     _direction?: Element;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DataRequirement.js b/vendor/r4/types/hl7-fhir-r4-core/DataRequirement.js
index c8ad2e5..4287da9 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DataRequirement.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/DataRequirement.js
@@ -1,2 +1,226 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataRequirementDirection = exports.DataRequirementType = void 0;
+/** The type of the required data */
+var DataRequirementType;
+(function (DataRequirementType) {
+    DataRequirementType["ImmunizationEvaluation"] = "ImmunizationEvaluation";
+    DataRequirementType["Appointment"] = "Appointment";
+    DataRequirementType["StructureMap"] = "StructureMap";
+    DataRequirementType["Address"] = "Address";
+    DataRequirementType["CareTeam"] = "CareTeam";
+    DataRequirementType["UsageContext"] = "UsageContext";
+    DataRequirementType["Linkage"] = "Linkage";
+    DataRequirementType["Annotation"] = "Annotation";
+    DataRequirementType["Age"] = "Age";
+    DataRequirementType["Attachment"] = "Attachment";
+    DataRequirementType["Communication"] = "Communication";
+    DataRequirementType["MedicationDispense"] = "MedicationDispense";
+    DataRequirementType["ImagingStudy"] = "ImagingStudy";
+    DataRequirementType["ChargeItem"] = "ChargeItem";
+    DataRequirementType["Period"] = "Period";
+    DataRequirementType["AdverseEvent"] = "AdverseEvent";
+    DataRequirementType["ContactDetail"] = "ContactDetail";
+    DataRequirementType["DataRequirement"] = "DataRequirement";
+    DataRequirementType["Media"] = "Media";
+    DataRequirementType["CodeableConcept"] = "CodeableConcept";
+    DataRequirementType["Uri"] = "uri";
+    DataRequirementType["SubstancePolymer"] = "SubstancePolymer";
+    DataRequirementType["QuestionnaireResponse"] = "QuestionnaireResponse";
+    DataRequirementType["Coverage"] = "Coverage";
+    DataRequirementType["Procedure"] = "Procedure";
+    DataRequirementType["AuditEvent"] = "AuditEvent";
+    DataRequirementType["PaymentReconciliation"] = "PaymentReconciliation";
+    DataRequirementType["MedicinalProductManufactured"] = "MedicinalProductManufactured";
+    DataRequirementType["CompartmentDefinition"] = "CompartmentDefinition";
+    DataRequirementType["Type"] = "Type";
+    DataRequirementType["Organization"] = "Organization";
+    DataRequirementType["ExplanationOfBenefit"] = "ExplanationOfBenefit";
+    DataRequirementType["Composition"] = "Composition";
+    DataRequirementType["SimpleQuantity"] = "SimpleQuantity";
+    DataRequirementType["CoverageEligibilityResponse"] = "CoverageEligibilityResponse";
+    DataRequirementType["DocumentReference"] = "DocumentReference";
+    DataRequirementType["EventDefinition"] = "EventDefinition";
+    DataRequirementType["SubstanceProtein"] = "SubstanceProtein";
+    DataRequirementType["TerminologyCapabilities"] = "TerminologyCapabilities";
+    DataRequirementType["Encounter"] = "Encounter";
+    DataRequirementType["ImplementationGuide"] = "ImplementationGuide";
+    DataRequirementType["EvidenceVariable"] = "EvidenceVariable";
+    DataRequirementType["ObservationDefinition"] = "ObservationDefinition";
+    DataRequirementType["DiagnosticReport"] = "DiagnosticReport";
+    DataRequirementType["ExampleScenario"] = "ExampleScenario";
+    DataRequirementType["ResearchDefinition"] = "ResearchDefinition";
+    DataRequirementType["Parameters"] = "Parameters";
+    DataRequirementType["Instant"] = "instant";
+    DataRequirementType["SearchParameter"] = "SearchParameter";
+    DataRequirementType["MedicinalProductInteraction"] = "MedicinalProductInteraction";
+    DataRequirementType["CodeSystem"] = "CodeSystem";
+    DataRequirementType["MessageDefinition"] = "MessageDefinition";
+    DataRequirementType["NutritionOrder"] = "NutritionOrder";
+    DataRequirementType["VerificationResult"] = "VerificationResult";
+    DataRequirementType["MedicationAdministration"] = "MedicationAdministration";
+    DataRequirementType["CatalogEntry"] = "CatalogEntry";
+    DataRequirementType["Flag"] = "Flag";
+    DataRequirementType["DeviceUseStatement"] = "DeviceUseStatement";
+    DataRequirementType["TriggerDefinition"] = "TriggerDefinition";
+    DataRequirementType["Contract"] = "Contract";
+    DataRequirementType["Invoice"] = "Invoice";
+    DataRequirementType["MarketingStatus"] = "MarketingStatus";
+    DataRequirementType["Count"] = "Count";
+    DataRequirementType["PaymentNotice"] = "PaymentNotice";
+    DataRequirementType["Location"] = "Location";
+    DataRequirementType["Claim"] = "Claim";
+    DataRequirementType["Specimen"] = "Specimen";
+    DataRequirementType["MedicationStatement"] = "MedicationStatement";
+    DataRequirementType["EnrollmentResponse"] = "EnrollmentResponse";
+    DataRequirementType["Uuid"] = "uuid";
+    DataRequirementType["Evidence"] = "Evidence";
+    DataRequirementType["Bundle"] = "Bundle";
+    DataRequirementType["ResearchElementDefinition"] = "ResearchElementDefinition";
+    DataRequirementType["Expression"] = "Expression";
+    DataRequirementType["Coding"] = "Coding";
+    DataRequirementType["BodyStructure"] = "BodyStructure";
+    DataRequirementType["MedicinalProduct"] = "MedicinalProduct";
+    DataRequirementType["Canonical"] = "canonical";
+    DataRequirementType["ResearchStudy"] = "ResearchStudy";
+    DataRequirementType["Dosage"] = "Dosage";
+    DataRequirementType["AppointmentResponse"] = "AppointmentResponse";
+    DataRequirementType["MedicinalProductIndication"] = "MedicinalProductIndication";
+    DataRequirementType["Measure"] = "Measure";
+    DataRequirementType["Person"] = "Person";
+    DataRequirementType["InsurancePlan"] = "InsurancePlan";
+    DataRequirementType["Date"] = "date";
+    DataRequirementType["Patient"] = "Patient";
+    DataRequirementType["EffectEvidenceSynthesis"] = "EffectEvidenceSynthesis";
+    DataRequirementType["ResearchSubject"] = "ResearchSubject";
+    DataRequirementType["Medication"] = "Medication";
+    DataRequirementType["Range"] = "Range";
+    DataRequirementType["ConceptMap"] = "ConceptMap";
+    DataRequirementType["CoverageEligibilityRequest"] = "CoverageEligibilityRequest";
+    DataRequirementType["Population"] = "Population";
+    DataRequirementType["SubstanceSourceMaterial"] = "SubstanceSourceMaterial";
+    DataRequirementType["VisionPrescription"] = "VisionPrescription";
+    DataRequirementType["MolecularSequence"] = "MolecularSequence";
+    DataRequirementType["MedicinalProductUndesirableEffect"] = "MedicinalProductUndesirableEffect";
+    DataRequirementType["OperationOutcome"] = "OperationOutcome";
+    DataRequirementType["MessageHeader"] = "MessageHeader";
+    DataRequirementType["ContactPoint"] = "ContactPoint";
+    DataRequirementType["Signature"] = "Signature";
+    DataRequirementType["Decimal"] = "decimal";
+    DataRequirementType["Any"] = "Any";
+    DataRequirementType["AllergyIntolerance"] = "AllergyIntolerance";
+    DataRequirementType["SubstanceReferenceInformation"] = "SubstanceReferenceInformation";
+    DataRequirementType["SupplyDelivery"] = "SupplyDelivery";
+    DataRequirementType["EpisodeOfCare"] = "EpisodeOfCare";
+    DataRequirementType["PractitionerRole"] = "PractitionerRole";
+    DataRequirementType["Library"] = "Library";
+    DataRequirementType["Practitioner"] = "Practitioner";
+    DataRequirementType["Markdown"] = "markdown";
+    DataRequirementType["MedicationRequest"] = "MedicationRequest";
+    DataRequirementType["ImmunizationRecommendation"] = "ImmunizationRecommendation";
+    DataRequirementType["RelatedArtifact"] = "RelatedArtifact";
+    DataRequirementType["Timing"] = "Timing";
+    DataRequirementType["Immunization"] = "Immunization";
+    DataRequirementType["GraphDefinition"] = "GraphDefinition";
+    DataRequirementType["Account"] = "Account";
+    DataRequirementType["Url"] = "url";
+    DataRequirementType["MedicinalProductIngredient"] = "MedicinalProductIngredient";
+    DataRequirementType["ProdCharacteristic"] = "ProdCharacteristic";
+    DataRequirementType["Meta"] = "Meta";
+    DataRequirementType["Quantity"] = "Quantity";
+    DataRequirementType["MeasureReport"] = "MeasureReport";
+    DataRequirementType["Distance"] = "Distance";
+    DataRequirementType["HumanName"] = "HumanName";
+    DataRequirementType["DeviceMetric"] = "DeviceMetric";
+    DataRequirementType["Duration"] = "Duration";
+    DataRequirementType["SubstanceAmount"] = "SubstanceAmount";
+    DataRequirementType["Goal"] = "Goal";
+    DataRequirementType["MedicationKnowledge"] = "MedicationKnowledge";
+    DataRequirementType["Integer"] = "integer";
+    DataRequirementType["String"] = "string";
+    DataRequirementType["ClaimResponse"] = "ClaimResponse";
+    DataRequirementType["DeviceDefinition"] = "DeviceDefinition";
+    DataRequirementType["Slot"] = "Slot";
+    DataRequirementType["ValueSet"] = "ValueSet";
+    DataRequirementType["MedicinalProductAuthorization"] = "MedicinalProductAuthorization";
+    DataRequirementType["StructureDefinition"] = "StructureDefinition";
+    DataRequirementType["Base64Binary"] = "base64Binary";
+    DataRequirementType["MedicinalProductContraindication"] = "MedicinalProductContraindication";
+    DataRequirementType["ElementDefinition"] = "ElementDefinition";
+    DataRequirementType["DeviceRequest"] = "DeviceRequest";
+    DataRequirementType["List"] = "List";
+    DataRequirementType["Questionnaire"] = "Questionnaire";
+    DataRequirementType["DomainResource"] = "DomainResource";
+    DataRequirementType["Endpoint"] = "Endpoint";
+    DataRequirementType["NamingSystem"] = "NamingSystem";
+    DataRequirementType["MedicinalProductPackaged"] = "MedicinalProductPackaged";
+    DataRequirementType["Basic"] = "Basic";
+    DataRequirementType["Money"] = "Money";
+    DataRequirementType["Binary"] = "Binary";
+    DataRequirementType["PlanDefinition"] = "PlanDefinition";
+    DataRequirementType["Subscription"] = "Subscription";
+    DataRequirementType["SampledData"] = "SampledData";
+    DataRequirementType["ProductShelfLife"] = "ProductShelfLife";
+    DataRequirementType["RelatedPerson"] = "RelatedPerson";
+    DataRequirementType["SubstanceSpecification"] = "SubstanceSpecification";
+    DataRequirementType["Ratio"] = "Ratio";
+    DataRequirementType["SubstanceNucleicAcid"] = "SubstanceNucleicAcid";
+    DataRequirementType["GuidanceResponse"] = "GuidanceResponse";
+    DataRequirementType["ClinicalImpression"] = "ClinicalImpression";
+    DataRequirementType["OrganizationAffiliation"] = "OrganizationAffiliation";
+    DataRequirementType["Resource"] = "Resource";
+    DataRequirementType["UnsignedInt"] = "unsignedInt";
+    DataRequirementType["Condition"] = "Condition";
+    DataRequirementType["Extension"] = "Extension";
+    DataRequirementType["CapabilityStatement"] = "CapabilityStatement";
+    DataRequirementType["HealthcareService"] = "HealthcareService";
+    DataRequirementType["SpecimenDefinition"] = "SpecimenDefinition";
+    DataRequirementType["ParameterDefinition"] = "ParameterDefinition";
+    DataRequirementType["RiskAssessment"] = "RiskAssessment";
+    DataRequirementType["Xhtml"] = "xhtml";
+    DataRequirementType["OperationDefinition"] = "OperationDefinition";
+    DataRequirementType["ActivityDefinition"] = "ActivityDefinition";
+    DataRequirementType["Schedule"] = "Schedule";
+    DataRequirementType["BiologicallyDerivedProduct"] = "BiologicallyDerivedProduct";
+    DataRequirementType["PositiveInt"] = "positiveInt";
+    DataRequirementType["Code"] = "code";
+    DataRequirementType["Group"] = "Group";
+    DataRequirementType["MedicinalProductPharmaceutical"] = "MedicinalProductPharmaceutical";
+    DataRequirementType["FamilyMemberHistory"] = "FamilyMemberHistory";
+    DataRequirementType["ServiceRequest"] = "ServiceRequest";
+    DataRequirementType["DetectedIssue"] = "DetectedIssue";
+    DataRequirementType["Device"] = "Device";
+    DataRequirementType["Oid"] = "oid";
+    DataRequirementType["RequestGroup"] = "RequestGroup";
+    DataRequirementType["TestScript"] = "TestScript";
+    DataRequirementType["RiskEvidenceSynthesis"] = "RiskEvidenceSynthesis";
+    DataRequirementType["SupplyRequest"] = "SupplyRequest";
+    DataRequirementType["Element"] = "Element";
+    DataRequirementType["Reference"] = "Reference";
+    DataRequirementType["Task"] = "Task";
+    DataRequirementType["Identifier"] = "Identifier";
+    DataRequirementType["CommunicationRequest"] = "CommunicationRequest";
+    DataRequirementType["EnrollmentRequest"] = "EnrollmentRequest";
+    DataRequirementType["ChargeItemDefinition"] = "ChargeItemDefinition";
+    DataRequirementType["Substance"] = "Substance";
+    DataRequirementType["Id"] = "id";
+    DataRequirementType["Provenance"] = "Provenance";
+    DataRequirementType["Time"] = "time";
+    DataRequirementType["Consent"] = "Consent";
+    DataRequirementType["BackboneElement"] = "BackboneElement";
+    DataRequirementType["CarePlan"] = "CarePlan";
+    DataRequirementType["Narrative"] = "Narrative";
+    DataRequirementType["MoneyQuantity"] = "MoneyQuantity";
+    DataRequirementType["TestReport"] = "TestReport";
+    DataRequirementType["Observation"] = "Observation";
+    DataRequirementType["DateTime"] = "dateTime";
+    DataRequirementType["Boolean"] = "boolean";
+    DataRequirementType["DocumentManifest"] = "DocumentManifest";
+    DataRequirementType["Contributor"] = "Contributor";
+})(DataRequirementType = exports.DataRequirementType || (exports.DataRequirementType = {}));
+/** ascending | descending */
+var DataRequirementDirection;
+(function (DataRequirementDirection) {
+    DataRequirementDirection["Ascending"] = "ascending";
+    DataRequirementDirection["Descending"] = "descending";
+})(DataRequirementDirection = exports.DataRequirementDirection || (exports.DataRequirementDirection = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DetectedIssue.d.ts b/vendor/r4/types/hl7-fhir-r4-core/DetectedIssue.d.ts
index 190412e..0c3009a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DetectedIssue.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/DetectedIssue.d.ts
@@ -7,13 +7,13 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, Ineffective treatment frequency, Procedure-condition conflict, etc. */
 export interface DetectedIssue extends DomainResource {
+    resourceType: 'DetectedIssue';
     /** Associated patient */
-    patient?: Reference<"Patient">;
+    patient?: Reference<'Patient'>;
     _identifiedDateTime?: Element;
     _reference?: Element;
     /** Supporting evidence */
@@ -22,14 +22,14 @@ export interface DetectedIssue extends DomainResource {
     /** Step taken to address */
     mitigation?: Array<DetectedIssueMitigation>;
     /** The provider or device that identified the issue */
-    author?: Reference<"PractitionerRole" | "Device" | "Practitioner">;
+    author?: Reference<'PractitionerRole' | 'Device' | 'Practitioner'>;
     identifiedDateTime?: dateTime;
     /** Authority for issue */
     reference?: uri;
     /** registered | preliminary | final | amended + */
-    status: code;
+    status: `${DetectedIssueStatus}`;
     /** high | moderate | low */
-    severity?: code;
+    severity?: `${DetectedIssueSeverity}`;
     /** Issue Category, e.g. drug-drug, duplicate therapy, etc. */
     code?: CodeableConcept;
     /** Unique id for the detected issue */
@@ -57,5 +57,22 @@ export interface DetectedIssueMitigation extends BackboneElement {
     date?: dateTime;
     _date?: Element;
     /** Who is committing? */
-    author?: Reference<"PractitionerRole" | "Practitioner">;
+    author?: Reference<'PractitionerRole' | 'Practitioner'>;
+}
+/** registered | preliminary | final | amended + */
+export declare enum DetectedIssueStatus {
+    Amended = "amended",
+    Cancelled = "cancelled",
+    Corrected = "corrected",
+    EnteredInError = "entered-in-error",
+    Final = "final",
+    Preliminary = "preliminary",
+    Registered = "registered",
+    Unknown = "unknown"
+}
+/** high | moderate | low */
+export declare enum DetectedIssueSeverity {
+    High = "high",
+    Low = "low",
+    Moderate = "moderate"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DetectedIssue.js b/vendor/r4/types/hl7-fhir-r4-core/DetectedIssue.js
index c8ad2e5..e21dc9d 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DetectedIssue.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/DetectedIssue.js
@@ -1,2 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DetectedIssueSeverity = exports.DetectedIssueStatus = void 0;
+/** registered | preliminary | final | amended + */
+var DetectedIssueStatus;
+(function (DetectedIssueStatus) {
+    DetectedIssueStatus["Amended"] = "amended";
+    DetectedIssueStatus["Cancelled"] = "cancelled";
+    DetectedIssueStatus["Corrected"] = "corrected";
+    DetectedIssueStatus["EnteredInError"] = "entered-in-error";
+    DetectedIssueStatus["Final"] = "final";
+    DetectedIssueStatus["Preliminary"] = "preliminary";
+    DetectedIssueStatus["Registered"] = "registered";
+    DetectedIssueStatus["Unknown"] = "unknown";
+})(DetectedIssueStatus = exports.DetectedIssueStatus || (exports.DetectedIssueStatus = {}));
+/** high | moderate | low */
+var DetectedIssueSeverity;
+(function (DetectedIssueSeverity) {
+    DetectedIssueSeverity["High"] = "high";
+    DetectedIssueSeverity["Low"] = "low";
+    DetectedIssueSeverity["Moderate"] = "moderate";
+})(DetectedIssueSeverity = exports.DetectedIssueSeverity || (exports.DetectedIssueSeverity = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Device.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Device.d.ts
index 13c37e6..14617c5 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Device.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Device.d.ts
@@ -10,19 +10,19 @@ import { DomainResource } from "./DomainResource";
 import { base64Binary } from "./base64Binary";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device. */
 export interface Device extends DomainResource {
+    resourceType: 'Device';
     /** Patient to whom Device is affixed */
-    patient?: Reference<"Patient">;
+    patient?: Reference<'Patient'>;
     /** The reference to the definition for the device */
-    definition?: Reference<"DeviceDefinition">;
+    definition?: Reference<'DeviceDefinition'>;
     /** Serial number assigned by the manufacturer */
     serialNumber?: string;
     /** The parent device */
-    parent?: Reference<"Device">;
+    parent?: Reference<'Device'>;
     /** The name of the device as given by the manufacturer */
     deviceName?: Array<DeviceDeviceName>;
     _partNumber?: Element;
@@ -47,7 +47,7 @@ export interface Device extends DomainResource {
     /** Device notes and comments */
     note?: Array<Annotation>;
     /** active | inactive | entered-in-error | unknown */
-    status?: code;
+    status?: `${DeviceStatus}`;
     /** Safety Characteristics of Device */
     safety?: Array<CodeableConcept>;
     /** Lot number of manufacture */
@@ -65,26 +65,35 @@ export interface Device extends DomainResource {
     version?: Array<DeviceVersion>;
     _lotNumber?: Element;
     /** Where the device is found */
-    location?: Reference<"Location">;
+    location?: Reference<'Location'>;
     /** Details for human/organization for support */
     contact?: Array<ContactPoint>;
     /** Date when the device was made */
     manufactureDate?: dateTime;
     /** Organization responsible for device */
-    owner?: Reference<"Organization">;
+    owner?: Reference<'Organization'>;
     _url?: Element;
     /** Date and time of expiry of this device (if applicable) */
     expirationDate?: dateTime;
     /** Unique Device Identifier (UDI) Barcode string */
     udiCarrier?: Array<DeviceUdiCarrier>;
 }
+/** udi-label-name | user-friendly-name | patient-reported-name | manufacturer-name | model-name | other */
+export declare enum DeviceType {
+    ManufacturerName = "manufacturer-name",
+    ModelName = "model-name",
+    Other = "other",
+    PatientReportedName = "patient-reported-name",
+    UdiLabelName = "udi-label-name",
+    UserFriendlyName = "user-friendly-name"
+}
 /** The name of the device as given by the manufacturer */
 export interface DeviceDeviceName extends BackboneElement {
     /** The name of the device */
     name: string;
     _name?: Element;
     /** udi-label-name | user-friendly-name | patient-reported-name | manufacturer-name | model-name | other */
-    type: code;
+    type: `${DeviceType}`;
     _type?: Element;
 }
 /** The actual configuration settings of a device as it actually operates, e.g., regulation status, time properties */
@@ -104,6 +113,13 @@ export interface DeviceSpecialization extends BackboneElement {
     version?: string;
     _version?: Element;
 }
+/** active | inactive | entered-in-error | unknown */
+export declare enum DeviceStatus {
+    Active = "active",
+    EnteredInError = "entered-in-error",
+    Inactive = "inactive",
+    Unknown = "unknown"
+}
 /** The actual design of the device or software version running on the device */
 export interface DeviceVersion extends BackboneElement {
     /** The type of the device version */
@@ -114,6 +130,15 @@ export interface DeviceVersion extends BackboneElement {
     value: string;
     _value?: Element;
 }
+/** barcode | rfid | manual + */
+export declare enum DeviceEntryType {
+    Barcode = "barcode",
+    Card = "card",
+    Manual = "manual",
+    Rfid = "rfid",
+    SelfReported = "self-reported",
+    Unknown = "unknown"
+}
 /** Unique Device Identifier (UDI) Barcode string */
 export interface DeviceUdiCarrier extends BackboneElement {
     _jurisdiction?: Element;
@@ -123,7 +148,7 @@ export interface DeviceUdiCarrier extends BackboneElement {
     /** Regional UDI authority */
     jurisdiction?: uri;
     /** barcode | rfid | manual + */
-    entryType?: code;
+    entryType?: `${DeviceEntryType}`;
     /** UDI Issuing Organization */
     issuer?: uri;
     _deviceIdentifier?: Element;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Device.js b/vendor/r4/types/hl7-fhir-r4-core/Device.js
index c8ad2e5..6e6f14d 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Device.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Device.js
@@ -1,2 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceEntryType = exports.DeviceStatus = exports.DeviceType = void 0;
+/** udi-label-name | user-friendly-name | patient-reported-name | manufacturer-name | model-name | other */
+var DeviceType;
+(function (DeviceType) {
+    DeviceType["ManufacturerName"] = "manufacturer-name";
+    DeviceType["ModelName"] = "model-name";
+    DeviceType["Other"] = "other";
+    DeviceType["PatientReportedName"] = "patient-reported-name";
+    DeviceType["UdiLabelName"] = "udi-label-name";
+    DeviceType["UserFriendlyName"] = "user-friendly-name";
+})(DeviceType = exports.DeviceType || (exports.DeviceType = {}));
+/** active | inactive | entered-in-error | unknown */
+var DeviceStatus;
+(function (DeviceStatus) {
+    DeviceStatus["Active"] = "active";
+    DeviceStatus["EnteredInError"] = "entered-in-error";
+    DeviceStatus["Inactive"] = "inactive";
+    DeviceStatus["Unknown"] = "unknown";
+})(DeviceStatus = exports.DeviceStatus || (exports.DeviceStatus = {}));
+/** barcode | rfid | manual + */
+var DeviceEntryType;
+(function (DeviceEntryType) {
+    DeviceEntryType["Barcode"] = "barcode";
+    DeviceEntryType["Card"] = "card";
+    DeviceEntryType["Manual"] = "manual";
+    DeviceEntryType["Rfid"] = "rfid";
+    DeviceEntryType["SelfReported"] = "self-reported";
+    DeviceEntryType["Unknown"] = "unknown";
+})(DeviceEntryType = exports.DeviceEntryType || (exports.DeviceEntryType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DeviceDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/DeviceDefinition.d.ts
index a47aff8..22eed62 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DeviceDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/DeviceDefinition.d.ts
@@ -10,11 +10,11 @@ import { DomainResource } from "./DomainResource";
 import { ProductShelfLife } from "./ProductShelfLife";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** The characteristics, operational status and capabilities of a medical-related component of a medical device. */
 export interface DeviceDefinition extends DomainResource {
+    resourceType: 'DeviceDefinition';
     /** A name given to the device to identify it */
     deviceName?: Array<DeviceDefinitionDeviceName>;
     /** Shelf Life and storage information */
@@ -30,13 +30,13 @@ export interface DeviceDefinition extends DomainResource {
     udiDeviceIdentifier?: Array<DeviceDefinitionUdiDeviceIdentifier>;
     /** What kind of device or device system this is */
     type?: CodeableConcept;
-    manufacturerReference?: Reference<"Organization">;
+    manufacturerReference?: Reference<'Organization'>;
     /** Device capabilities */
     capability?: Array<DeviceDefinitionCapability>;
     /** The capabilities supported on a  device, the standards to which the device conforms for a particular purpose, and used for the communication */
     specialization?: Array<DeviceDefinitionSpecialization>;
     /** The parent device it can be part of */
-    parentDevice?: Reference<"DeviceDefinition">;
+    parentDevice?: Reference<'DeviceDefinition'>;
     /** Device notes and comments */
     note?: Array<Annotation>;
     /** Language code for the human-readable text strings produced by the device (all supported) */
@@ -57,7 +57,7 @@ export interface DeviceDefinition extends DomainResource {
     /** Details for human/organization for support */
     contact?: Array<ContactPoint>;
     /** Organization responsible for device */
-    owner?: Reference<"Organization">;
+    owner?: Reference<'Organization'>;
     _url?: Element;
     /** Access to on-line information */
     onlineInformation?: uri;
@@ -65,13 +65,22 @@ export interface DeviceDefinition extends DomainResource {
     physicalCharacteristics?: ProdCharacteristic;
     _manufacturerString?: Element;
 }
+/** udi-label-name | user-friendly-name | patient-reported-name | manufacturer-name | model-name | other */
+export declare enum DeviceDefinitionType {
+    ManufacturerName = "manufacturer-name",
+    ModelName = "model-name",
+    Other = "other",
+    PatientReportedName = "patient-reported-name",
+    UdiLabelName = "udi-label-name",
+    UserFriendlyName = "user-friendly-name"
+}
 /** A name given to the device to identify it */
 export interface DeviceDefinitionDeviceName extends BackboneElement {
     /** The name of the device */
     name: string;
     _name?: Element;
     /** udi-label-name | user-friendly-name | patient-reported-name | manufacturer-name | model-name | other */
-    type: code;
+    type: `${DeviceDefinitionType}`;
     _type?: Element;
 }
 /** The actual configuration settings of a device as it actually operates, e.g., regulation status, time properties */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DeviceDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/DeviceDefinition.js
index c8ad2e5..5e9a373 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DeviceDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/DeviceDefinition.js
@@ -1,2 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceDefinitionType = void 0;
+/** udi-label-name | user-friendly-name | patient-reported-name | manufacturer-name | model-name | other */
+var DeviceDefinitionType;
+(function (DeviceDefinitionType) {
+    DeviceDefinitionType["ManufacturerName"] = "manufacturer-name";
+    DeviceDefinitionType["ModelName"] = "model-name";
+    DeviceDefinitionType["Other"] = "other";
+    DeviceDefinitionType["PatientReportedName"] = "patient-reported-name";
+    DeviceDefinitionType["UdiLabelName"] = "udi-label-name";
+    DeviceDefinitionType["UserFriendlyName"] = "user-friendly-name";
+})(DeviceDefinitionType = exports.DeviceDefinitionType || (exports.DeviceDefinitionType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DeviceMetric.d.ts b/vendor/r4/types/hl7-fhir-r4-core/DeviceMetric.d.ts
index e4e3708..3f0a381 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DeviceMetric.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/DeviceMetric.d.ts
@@ -6,44 +6,83 @@ import { DomainResource } from "./DomainResource";
 import { instant } from "./instant";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Describes a measurement, calculation or setting capability of a medical device. */
 export interface DeviceMetric extends DomainResource {
+    resourceType: 'DeviceMetric';
     /** measurement | setting | calculation | unspecified */
-    category: code;
+    category: `${DeviceMetricCategory}`;
     _color?: Element;
     /** Describes the measurement repetition time */
     measurementPeriod?: Timing;
     /** black | red | green | yellow | blue | magenta | cyan | white */
-    color?: code;
+    color?: `${DeviceMetricColor}`;
     /** Describes the link to the parent Device */
-    parent?: Reference<"Device">;
+    parent?: Reference<'Device'>;
     /** Unit of Measure for the Metric */
     unit?: CodeableConcept;
     /** Identity of metric, for example Heart Rate or PEEP Setting */
     type: CodeableConcept;
     /** Describes the link to the source Device */
-    source?: Reference<"Device">;
+    source?: Reference<'Device'>;
     _operationalStatus?: Element;
     /** Instance identifier */
     identifier?: Array<Identifier>;
     /** Describes the calibrations that have been performed or that are required to be performed */
     calibration?: Array<DeviceMetricCalibration>;
     /** on | off | standby | entered-in-error */
-    operationalStatus?: code;
+    operationalStatus?: `${DeviceMetricOperationalStatus}`;
     _category?: Element;
 }
+/** measurement | setting | calculation | unspecified */
+export declare enum DeviceMetricCategory {
+    Calculation = "calculation",
+    Measurement = "measurement",
+    Setting = "setting",
+    Unspecified = "unspecified"
+}
+/** black | red | green | yellow | blue | magenta | cyan | white */
+export declare enum DeviceMetricColor {
+    Black = "black",
+    Blue = "blue",
+    Cyan = "cyan",
+    Green = "green",
+    Magenta = "magenta",
+    Red = "red",
+    White = "white",
+    Yellow = "yellow"
+}
+/** unspecified | offset | gain | two-point */
+export declare enum DeviceMetricType {
+    Gain = "gain",
+    Offset = "offset",
+    TwoPoint = "two-point",
+    Unspecified = "unspecified"
+}
+/** not-calibrated | calibration-required | calibrated | unspecified */
+export declare enum DeviceMetricState {
+    Calibrated = "calibrated",
+    CalibrationRequired = "calibration-required",
+    NotCalibrated = "not-calibrated",
+    Unspecified = "unspecified"
+}
 /** Describes the calibrations that have been performed or that are required to be performed */
 export interface DeviceMetricCalibration extends BackboneElement {
     /** unspecified | offset | gain | two-point */
-    type?: code;
+    type?: `${DeviceMetricType}`;
     _type?: Element;
     /** not-calibrated | calibration-required | calibrated | unspecified */
-    state?: code;
+    state?: `${DeviceMetricState}`;
     _state?: Element;
     /** Describes the time last calibration has been performed */
     time?: instant;
     _time?: Element;
 }
+/** on | off | standby | entered-in-error */
+export declare enum DeviceMetricOperationalStatus {
+    EnteredInError = "entered-in-error",
+    Off = "off",
+    On = "on",
+    Standby = "standby"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DeviceMetric.js b/vendor/r4/types/hl7-fhir-r4-core/DeviceMetric.js
index c8ad2e5..b082cd0 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DeviceMetric.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/DeviceMetric.js
@@ -1,2 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceMetricOperationalStatus = exports.DeviceMetricState = exports.DeviceMetricType = exports.DeviceMetricColor = exports.DeviceMetricCategory = void 0;
+/** measurement | setting | calculation | unspecified */
+var DeviceMetricCategory;
+(function (DeviceMetricCategory) {
+    DeviceMetricCategory["Calculation"] = "calculation";
+    DeviceMetricCategory["Measurement"] = "measurement";
+    DeviceMetricCategory["Setting"] = "setting";
+    DeviceMetricCategory["Unspecified"] = "unspecified";
+})(DeviceMetricCategory = exports.DeviceMetricCategory || (exports.DeviceMetricCategory = {}));
+/** black | red | green | yellow | blue | magenta | cyan | white */
+var DeviceMetricColor;
+(function (DeviceMetricColor) {
+    DeviceMetricColor["Black"] = "black";
+    DeviceMetricColor["Blue"] = "blue";
+    DeviceMetricColor["Cyan"] = "cyan";
+    DeviceMetricColor["Green"] = "green";
+    DeviceMetricColor["Magenta"] = "magenta";
+    DeviceMetricColor["Red"] = "red";
+    DeviceMetricColor["White"] = "white";
+    DeviceMetricColor["Yellow"] = "yellow";
+})(DeviceMetricColor = exports.DeviceMetricColor || (exports.DeviceMetricColor = {}));
+/** unspecified | offset | gain | two-point */
+var DeviceMetricType;
+(function (DeviceMetricType) {
+    DeviceMetricType["Gain"] = "gain";
+    DeviceMetricType["Offset"] = "offset";
+    DeviceMetricType["TwoPoint"] = "two-point";
+    DeviceMetricType["Unspecified"] = "unspecified";
+})(DeviceMetricType = exports.DeviceMetricType || (exports.DeviceMetricType = {}));
+/** not-calibrated | calibration-required | calibrated | unspecified */
+var DeviceMetricState;
+(function (DeviceMetricState) {
+    DeviceMetricState["Calibrated"] = "calibrated";
+    DeviceMetricState["CalibrationRequired"] = "calibration-required";
+    DeviceMetricState["NotCalibrated"] = "not-calibrated";
+    DeviceMetricState["Unspecified"] = "unspecified";
+})(DeviceMetricState = exports.DeviceMetricState || (exports.DeviceMetricState = {}));
+/** on | off | standby | entered-in-error */
+var DeviceMetricOperationalStatus;
+(function (DeviceMetricOperationalStatus) {
+    DeviceMetricOperationalStatus["EnteredInError"] = "entered-in-error";
+    DeviceMetricOperationalStatus["Off"] = "off";
+    DeviceMetricOperationalStatus["On"] = "on";
+    DeviceMetricOperationalStatus["Standby"] = "standby";
+})(DeviceMetricOperationalStatus = exports.DeviceMetricOperationalStatus || (exports.DeviceMetricOperationalStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DeviceRequest.d.ts b/vendor/r4/types/hl7-fhir-r4-core/DeviceRequest.d.ts
index 5f00252..410ef31 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DeviceRequest.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/DeviceRequest.d.ts
@@ -12,11 +12,11 @@ import { canonical } from "./canonical";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Represents a request for a patient to employ a medical device. The device may be an implantable device, or an external assistive device, such as a walker. */
 export interface DeviceRequest extends DomainResource {
+    resourceType: 'DeviceRequest';
     /** Filler role */
     performerType?: CodeableConcept;
     /** Associated insurance coverage */
@@ -31,7 +31,7 @@ export interface DeviceRequest extends DomainResource {
     /** Additional clinical information */
     supportingInfo?: Array<Reference>;
     /** Encounter motivating request */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     /** What request replaces */
     priorRequest?: Array<Reference>;
     _priority?: Element;
@@ -43,37 +43,66 @@ export interface DeviceRequest extends DomainResource {
     occurrenceTiming?: Timing;
     /** Notes or comments */
     note?: Array<Annotation>;
-    codeReference: Reference<"Device">;
+    codeReference: Reference<'Device'>;
     _intent?: Element;
     /** Who/what is requesting diagnostics */
-    requester?: Reference<"PractitionerRole" | "Organization" | "Device" | "Practitioner">;
+    requester?: Reference<'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner'>;
     /** routine | urgent | asap | stat */
-    priority?: code;
+    priority?: `${DeviceRequestPriority}`;
     occurrencePeriod?: Period;
     /** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
-    status?: code;
+    status?: `${DeviceRequestStatus}`;
     codeCodeableConcept: CodeableConcept;
     /** Identifier of composite request */
     groupIdentifier?: Identifier;
     /** External Request identifier */
     identifier?: Array<Identifier>;
     /** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
-    intent: code;
+    intent: `${DeviceRequestIntent}`;
     /** What request fulfills */
     basedOn?: Array<Reference>;
     occurrenceDateTime?: dateTime;
     _instantiatesCanonical?: Array<Element>;
     /** Focus of request */
-    subject: Reference<"Patient" | "Device" | "Location" | "Group">;
+    subject: Reference<'Patient' | 'Device' | 'Location' | 'Group'>;
     /** Device details */
     parameter?: Array<DeviceRequestParameter>;
     /** Requested Filler */
-    performer?: Reference<"CareTeam" | "Patient" | "PractitionerRole" | "HealthcareService" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    performer?: Reference<'CareTeam' | 'Patient' | 'PractitionerRole' | 'HealthcareService' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** Linked Reason for request */
     reasonReference?: Array<Reference>;
     _instantiatesUri?: Array<Element>;
     _occurrenceDateTime?: Element;
 }
+/** routine | urgent | asap | stat */
+export declare enum DeviceRequestPriority {
+    Asap = "asap",
+    Routine = "routine",
+    Stat = "stat",
+    Urgent = "urgent"
+}
+/** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
+export declare enum DeviceRequestStatus {
+    Active = "active",
+    Completed = "completed",
+    Draft = "draft",
+    EnteredInError = "entered-in-error",
+    OnHold = "on-hold",
+    Revoked = "revoked",
+    Unknown = "unknown"
+}
+/** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
+export declare enum DeviceRequestIntent {
+    Order = "order",
+    FillerOrder = "filler-order",
+    Option = "option",
+    Directive = "directive",
+    Proposal = "proposal",
+    ReflexOrder = "reflex-order",
+    Plan = "plan",
+    InstanceOrder = "instance-order",
+    OriginalOrder = "original-order"
+}
 /** Device details */
 export interface DeviceRequestParameter extends BackboneElement {
     /** Device detail */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DeviceRequest.js b/vendor/r4/types/hl7-fhir-r4-core/DeviceRequest.js
index c8ad2e5..89bfdf1 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DeviceRequest.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/DeviceRequest.js
@@ -1,2 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceRequestIntent = exports.DeviceRequestStatus = exports.DeviceRequestPriority = void 0;
+/** routine | urgent | asap | stat */
+var DeviceRequestPriority;
+(function (DeviceRequestPriority) {
+    DeviceRequestPriority["Asap"] = "asap";
+    DeviceRequestPriority["Routine"] = "routine";
+    DeviceRequestPriority["Stat"] = "stat";
+    DeviceRequestPriority["Urgent"] = "urgent";
+})(DeviceRequestPriority = exports.DeviceRequestPriority || (exports.DeviceRequestPriority = {}));
+/** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
+var DeviceRequestStatus;
+(function (DeviceRequestStatus) {
+    DeviceRequestStatus["Active"] = "active";
+    DeviceRequestStatus["Completed"] = "completed";
+    DeviceRequestStatus["Draft"] = "draft";
+    DeviceRequestStatus["EnteredInError"] = "entered-in-error";
+    DeviceRequestStatus["OnHold"] = "on-hold";
+    DeviceRequestStatus["Revoked"] = "revoked";
+    DeviceRequestStatus["Unknown"] = "unknown";
+})(DeviceRequestStatus = exports.DeviceRequestStatus || (exports.DeviceRequestStatus = {}));
+/** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
+var DeviceRequestIntent;
+(function (DeviceRequestIntent) {
+    DeviceRequestIntent["Order"] = "order";
+    DeviceRequestIntent["FillerOrder"] = "filler-order";
+    DeviceRequestIntent["Option"] = "option";
+    DeviceRequestIntent["Directive"] = "directive";
+    DeviceRequestIntent["Proposal"] = "proposal";
+    DeviceRequestIntent["ReflexOrder"] = "reflex-order";
+    DeviceRequestIntent["Plan"] = "plan";
+    DeviceRequestIntent["InstanceOrder"] = "instance-order";
+    DeviceRequestIntent["OriginalOrder"] = "original-order";
+})(DeviceRequestIntent = exports.DeviceRequestIntent || (exports.DeviceRequestIntent = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DeviceUseStatement.d.ts b/vendor/r4/types/hl7-fhir-r4-core/DeviceUseStatement.d.ts
index 1d32849..43af54a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DeviceUseStatement.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/DeviceUseStatement.d.ts
@@ -8,10 +8,10 @@ import { Timing } from "./Timing";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** A record of a device being used by a patient where the record is the result of a report from the patient or another clinician. */
 export interface DeviceUseStatement extends DomainResource {
+    resourceType: 'DeviceUseStatement';
     _recordedOn?: Element;
     /** Supporting information */
     derivedFrom?: Array<Reference>;
@@ -20,13 +20,13 @@ export interface DeviceUseStatement extends DomainResource {
     /** Why device was used */
     reasonCode?: Array<CodeableConcept>;
     /** Who made the statement */
-    source?: Reference<"Patient" | "PractitionerRole" | "Practitioner" | "RelatedPerson">;
+    source?: Reference<'Patient' | 'PractitionerRole' | 'Practitioner' | 'RelatedPerson'>;
     /** Addition details (comments, instructions) */
     note?: Array<Annotation>;
     timingDateTime?: dateTime;
     timingTiming?: Timing;
     /** active | completed | entered-in-error + */
-    status: code;
+    status: `${DeviceUseStatementStatus}`;
     /** When statement was recorded */
     recordedOn?: dateTime;
     /** External identifier for this record */
@@ -35,11 +35,20 @@ export interface DeviceUseStatement extends DomainResource {
     bodySite?: CodeableConcept;
     _timingDateTime?: Element;
     /** Reference to device used */
-    device: Reference<"Device">;
+    device: Reference<'Device'>;
     /** Fulfills plan, proposal or order */
     basedOn?: Array<Reference>;
     /** Patient using device */
-    subject: Reference<"Patient" | "Group">;
+    subject: Reference<'Patient' | 'Group'>;
     /** Why was DeviceUseStatement performed? */
     reasonReference?: Array<Reference>;
 }
+/** active | completed | entered-in-error + */
+export declare enum DeviceUseStatementStatus {
+    Active = "active",
+    Completed = "completed",
+    EnteredInError = "entered-in-error",
+    Intended = "intended",
+    OnHold = "on-hold",
+    Stopped = "stopped"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DeviceUseStatement.js b/vendor/r4/types/hl7-fhir-r4-core/DeviceUseStatement.js
index c8ad2e5..b762597 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DeviceUseStatement.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/DeviceUseStatement.js
@@ -1,2 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceUseStatementStatus = void 0;
+/** active | completed | entered-in-error + */
+var DeviceUseStatementStatus;
+(function (DeviceUseStatementStatus) {
+    DeviceUseStatementStatus["Active"] = "active";
+    DeviceUseStatementStatus["Completed"] = "completed";
+    DeviceUseStatementStatus["EnteredInError"] = "entered-in-error";
+    DeviceUseStatementStatus["Intended"] = "intended";
+    DeviceUseStatementStatus["OnHold"] = "on-hold";
+    DeviceUseStatementStatus["Stopped"] = "stopped";
+})(DeviceUseStatementStatus = exports.DeviceUseStatementStatus || (exports.DeviceUseStatementStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DiagnosticReport.d.ts b/vendor/r4/types/hl7-fhir-r4-core/DiagnosticReport.d.ts
index fa2f178..63c6e46 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DiagnosticReport.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/DiagnosticReport.d.ts
@@ -8,11 +8,11 @@ import { DomainResource } from "./DomainResource";
 import { instant } from "./instant";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** The findings and interpretation of diagnostic  tests performed on patients, groups of patients, devices, and locations, and/or specimens derived from these. The report includes clinical context such as requesting and provider information, and some mix of atomic results, images, textual and coded interpretations, and formatted representation of diagnostic reports. */
 export interface DiagnosticReport extends DomainResource {
+    resourceType: 'DiagnosticReport';
     /** Service category */
     category?: Array<CodeableConcept>;
     /** Codes for the clinical conclusion of test results */
@@ -22,7 +22,7 @@ export interface DiagnosticReport extends DomainResource {
     conclusion?: string;
     _effectiveDateTime?: Element;
     /** Health care event when test ordered */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     /** Specimens this report is based on */
     specimen?: Array<Reference>;
     _status?: Element;
@@ -30,7 +30,7 @@ export interface DiagnosticReport extends DomainResource {
     /** Primary result interpreter */
     resultsInterpreter?: Array<Reference>;
     /** registered | partial | preliminary | final + */
-    status: code;
+    status: `${DiagnosticReportStatus}`;
     /** Observations */
     result?: Array<Reference>;
     /** Name/Code for this diagnostic report */
@@ -48,17 +48,30 @@ export interface DiagnosticReport extends DomainResource {
     /** Key images associated with this report */
     media?: Array<DiagnosticReportMedia>;
     /** The subject of the report - usually, but not always, the patient */
-    subject?: Reference<"Patient" | "Device" | "Location" | "Group">;
+    subject?: Reference<'Patient' | 'Device' | 'Location' | 'Group'>;
     _conclusion?: Element;
     /** Responsible Diagnostic Service */
     performer?: Array<Reference>;
     effectivePeriod?: Period;
 }
+/** registered | partial | preliminary | final + */
+export declare enum DiagnosticReportStatus {
+    Cancelled = "cancelled",
+    Partial = "partial",
+    Amended = "amended",
+    Registered = "registered",
+    Corrected = "corrected",
+    Final = "final",
+    Preliminary = "preliminary",
+    Unknown = "unknown",
+    Appended = "appended",
+    EnteredInError = "entered-in-error"
+}
 /** Key images associated with this report */
 export interface DiagnosticReportMedia extends BackboneElement {
     /** Comment about the image (e.g. explanation) */
     comment?: string;
     _comment?: Element;
     /** Reference to the image source */
-    link: Reference<"Media">;
+    link: Reference<'Media'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DiagnosticReport.js b/vendor/r4/types/hl7-fhir-r4-core/DiagnosticReport.js
index c8ad2e5..b8c6e68 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DiagnosticReport.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/DiagnosticReport.js
@@ -1,2 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticReportStatus = void 0;
+/** registered | partial | preliminary | final + */
+var DiagnosticReportStatus;
+(function (DiagnosticReportStatus) {
+    DiagnosticReportStatus["Cancelled"] = "cancelled";
+    DiagnosticReportStatus["Partial"] = "partial";
+    DiagnosticReportStatus["Amended"] = "amended";
+    DiagnosticReportStatus["Registered"] = "registered";
+    DiagnosticReportStatus["Corrected"] = "corrected";
+    DiagnosticReportStatus["Final"] = "final";
+    DiagnosticReportStatus["Preliminary"] = "preliminary";
+    DiagnosticReportStatus["Unknown"] = "unknown";
+    DiagnosticReportStatus["Appended"] = "appended";
+    DiagnosticReportStatus["EnteredInError"] = "entered-in-error";
+})(DiagnosticReportStatus = exports.DiagnosticReportStatus || (exports.DiagnosticReportStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DocumentManifest.d.ts b/vendor/r4/types/hl7-fhir-r4-core/DocumentManifest.d.ts
index 338cba7..fa418b6 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DocumentManifest.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/DocumentManifest.d.ts
@@ -6,11 +6,11 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A collection of documents compiled for a purpose together with metadata that applies to the collection. */
 export interface DocumentManifest extends DomainResource {
+    resourceType: 'DocumentManifest';
     _created?: Element;
     /** Human-readable description (title) */
     description?: string;
@@ -33,12 +33,12 @@ export interface DocumentManifest extends DomainResource {
     /** Unique Identifier for the set of documents */
     masterIdentifier?: Identifier;
     /** current | superseded | entered-in-error */
-    status: code;
+    status: `${DocumentManifestStatus}`;
     /** Other identifiers for the manifest */
     identifier?: Array<Identifier>;
     _source?: Element;
     /** The subject of the set of documents */
-    subject?: Reference<"Patient" | "Device" | "Practitioner" | "Group">;
+    subject?: Reference<'Patient' | 'Device' | 'Practitioner' | 'Group'>;
 }
 /** Related things */
 export interface DocumentManifestRelated extends BackboneElement {
@@ -47,3 +47,9 @@ export interface DocumentManifestRelated extends BackboneElement {
     /** Related Resource */
     ref?: Reference;
 }
+/** current | superseded | entered-in-error */
+export declare enum DocumentManifestStatus {
+    Current = "current",
+    EnteredInError = "entered-in-error",
+    Superseded = "superseded"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DocumentManifest.js b/vendor/r4/types/hl7-fhir-r4-core/DocumentManifest.js
index c8ad2e5..b23adfa 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DocumentManifest.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/DocumentManifest.js
@@ -1,2 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentManifestStatus = void 0;
+/** current | superseded | entered-in-error */
+var DocumentManifestStatus;
+(function (DocumentManifestStatus) {
+    DocumentManifestStatus["Current"] = "current";
+    DocumentManifestStatus["EnteredInError"] = "entered-in-error";
+    DocumentManifestStatus["Superseded"] = "superseded";
+})(DocumentManifestStatus = exports.DocumentManifestStatus || (exports.DocumentManifestStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DocumentReference.d.ts b/vendor/r4/types/hl7-fhir-r4-core/DocumentReference.d.ts
index 3fb38a7..dd46892 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DocumentReference.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/DocumentReference.d.ts
@@ -8,11 +8,11 @@ import { DomainResource } from "./DomainResource";
 import { instant } from "./instant";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A reference to a document of any kind for any purpose. Provides metadata about the document so that the document can be discovered and managed. The scope of a document is any seralized object with a mime-type, so includes formal patient centric documents (CDA), cliical notes, scanned paper, and non-patient specific documents like policy text. */
 export interface DocumentReference extends DomainResource {
+    resourceType: 'DocumentReference';
     /** Human-readable description */
     description?: string;
     /** Categorization of document */
@@ -20,7 +20,7 @@ export interface DocumentReference extends DomainResource {
     /** When this document reference was created */
     date?: instant;
     /** preliminary | final | amended | entered-in-error */
-    docStatus?: code;
+    docStatus?: `${DocumentReferenceDocStatus}`;
     /** Document referenced */
     content: Array<DocumentReferenceContent>;
     _date?: Element;
@@ -33,9 +33,9 @@ export interface DocumentReference extends DomainResource {
     /** Master Version Specific Identifier */
     masterIdentifier?: Identifier;
     /** Organization which maintains the document */
-    custodian?: Reference<"Organization">;
+    custodian?: Reference<'Organization'>;
     /** current | superseded | entered-in-error */
-    status: code;
+    status: `${DocumentReferenceStatus}`;
     /** Other identifiers for the document */
     identifier?: Array<Identifier>;
     /** Relationships to other documents */
@@ -46,9 +46,16 @@ export interface DocumentReference extends DomainResource {
     securityLabel?: Array<CodeableConcept>;
     _docStatus?: Element;
     /** Who/what is the subject of the document */
-    subject?: Reference<"Patient" | "Device" | "Practitioner" | "Group">;
+    subject?: Reference<'Patient' | 'Device' | 'Practitioner' | 'Group'>;
     /** Who/what authenticated the document */
-    authenticator?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    authenticator?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
+}
+/** preliminary | final | amended | entered-in-error */
+export declare enum DocumentReferenceDocStatus {
+    Amended = "amended",
+    EnteredInError = "entered-in-error",
+    Final = "final",
+    Preliminary = "preliminary"
 }
 /** Document referenced */
 export interface DocumentReferenceContent extends BackboneElement {
@@ -57,13 +64,26 @@ export interface DocumentReferenceContent extends BackboneElement {
     /** Format/content rules for the document */
     format?: Coding;
 }
+/** current | superseded | entered-in-error */
+export declare enum DocumentReferenceStatus {
+    Current = "current",
+    EnteredInError = "entered-in-error",
+    Superseded = "superseded"
+}
+/** replaces | transforms | signs | appends */
+export declare enum DocumentReferenceCode {
+    Appends = "appends",
+    Replaces = "replaces",
+    Signs = "signs",
+    Transforms = "transforms"
+}
 /** Relationships to other documents */
 export interface DocumentReferenceRelatesTo extends BackboneElement {
     /** replaces | transforms | signs | appends */
-    code: code;
+    code: `${DocumentReferenceCode}`;
     _code?: Element;
     /** Target of the relationship */
-    target: Reference<"DocumentReference">;
+    target: Reference<'DocumentReference'>;
 }
 /** Clinical context of document */
 export interface DocumentReferenceContext extends BackboneElement {
@@ -78,7 +98,7 @@ export interface DocumentReferenceContext extends BackboneElement {
     /** Additional details about where the content was created (e.g. clinical specialty) */
     practiceSetting?: CodeableConcept;
     /** Patient demographics from source */
-    sourcePatientInfo?: Reference<"Patient">;
+    sourcePatientInfo?: Reference<'Patient'>;
     /** Related identifiers or resources */
     related?: Array<Reference>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/DocumentReference.js b/vendor/r4/types/hl7-fhir-r4-core/DocumentReference.js
index c8ad2e5..5b8ed27 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/DocumentReference.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/DocumentReference.js
@@ -1,2 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentReferenceCode = exports.DocumentReferenceStatus = exports.DocumentReferenceDocStatus = void 0;
+/** preliminary | final | amended | entered-in-error */
+var DocumentReferenceDocStatus;
+(function (DocumentReferenceDocStatus) {
+    DocumentReferenceDocStatus["Amended"] = "amended";
+    DocumentReferenceDocStatus["EnteredInError"] = "entered-in-error";
+    DocumentReferenceDocStatus["Final"] = "final";
+    DocumentReferenceDocStatus["Preliminary"] = "preliminary";
+})(DocumentReferenceDocStatus = exports.DocumentReferenceDocStatus || (exports.DocumentReferenceDocStatus = {}));
+/** current | superseded | entered-in-error */
+var DocumentReferenceStatus;
+(function (DocumentReferenceStatus) {
+    DocumentReferenceStatus["Current"] = "current";
+    DocumentReferenceStatus["EnteredInError"] = "entered-in-error";
+    DocumentReferenceStatus["Superseded"] = "superseded";
+})(DocumentReferenceStatus = exports.DocumentReferenceStatus || (exports.DocumentReferenceStatus = {}));
+/** replaces | transforms | signs | appends */
+var DocumentReferenceCode;
+(function (DocumentReferenceCode) {
+    DocumentReferenceCode["Appends"] = "appends";
+    DocumentReferenceCode["Replaces"] = "replaces";
+    DocumentReferenceCode["Signs"] = "signs";
+    DocumentReferenceCode["Transforms"] = "transforms";
+})(DocumentReferenceCode = exports.DocumentReferenceCode || (exports.DocumentReferenceCode = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/EffectEvidenceSynthesis.d.ts b/vendor/r4/types/hl7-fhir-r4-core/EffectEvidenceSynthesis.d.ts
index 93ba826..6237533 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/EffectEvidenceSynthesis.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/EffectEvidenceSynthesis.d.ts
@@ -14,16 +14,16 @@ import { date } from "./date";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** The EffectEvidenceSynthesis resource describes the difference in an outcome between exposures states in a population where the effect estimate is derived from a combination of research studies. */
 export interface EffectEvidenceSynthesis extends DomainResource {
+    resourceType: 'EffectEvidenceSynthesis';
     /** Natural language description of the effect evidence synthesis */
     description?: markdown;
     /** What comparison exposure? */
-    exposureAlternative: Reference<"EvidenceVariable">;
+    exposureAlternative: Reference<'EvidenceVariable'>;
     /** Date last changed */
     date?: dateTime;
     /** What was the estimated effect */
@@ -51,7 +51,7 @@ export interface EffectEvidenceSynthesis extends DomainResource {
     studyType?: CodeableConcept;
     _approvalDate?: Element;
     /** What outcome? */
-    outcome: Reference<"EvidenceVariable">;
+    outcome: Reference<'EvidenceVariable'>;
     /** The category of the EffectEvidenceSynthesis, such as Education, Treatment, Assessment, etc. */
     topic?: Array<CodeableConcept>;
     /** Name for this effect evidence synthesis (human friendly) */
@@ -65,9 +65,9 @@ export interface EffectEvidenceSynthesis extends DomainResource {
     synthesisType?: CodeableConcept;
     _lastReviewDate?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${EffectEvidenceSynthesisStatus}`;
     /** What population? */
-    population: Reference<"EvidenceVariable">;
+    population: Reference<'EvidenceVariable'>;
     _name?: Element;
     /** Canonical identifier for this effect evidence synthesis, represented as a URI (globally unique) */
     url?: uri;
@@ -84,7 +84,7 @@ export interface EffectEvidenceSynthesis extends DomainResource {
     /** Who reviewed the content */
     reviewer?: Array<ContactDetail>;
     /** What exposure? */
-    exposure: Reference<"EvidenceVariable">;
+    exposure: Reference<'EvidenceVariable'>;
     /** What was the result per exposure? */
     resultsByExposure?: Array<EffectEvidenceSynthesisResultsByExposure>;
     /** Business version of the effect evidence synthesis */
@@ -98,19 +98,14 @@ export interface EffectEvidenceSynthesis extends DomainResource {
     /** When the effect evidence synthesis is expected to be used */
     effectivePeriod?: Period;
 }
-/** How precise the estimate is */
-export interface EffectEvidenceSynthesisPrecisionEstimate extends BackboneElement {
-    /** Type of precision estimate */
-    type?: CodeableConcept;
-    /** Level of confidence interval */
-    level?: decimal;
-    _level?: Element;
-    /** Lower bound */
-    from?: decimal;
-    _from?: Element;
-    /** Upper bound */
-    to?: decimal;
-    _to?: Element;
+/** How certain is the effect */
+export interface EffectEvidenceSynthesisCertainty extends BackboneElement {
+    /** Certainty rating */
+    rating?: Array<CodeableConcept>;
+    /** Used for footnotes or explanatory notes */
+    note?: Array<Annotation>;
+    /** A component that contributes to the overall certainty */
+    certaintySubcomponent?: Array<EffectEvidenceSynthesisCertaintySubcomponent>;
 }
 /** What was the estimated effect */
 export interface EffectEvidenceSynthesisEffectEstimate extends BackboneElement {
@@ -125,7 +120,7 @@ export interface EffectEvidenceSynthesisEffectEstimate extends BackboneElement {
     value?: decimal;
     _value?: Element;
     /** What unit is the outcome described in? */
-    unitOfMeasure?: CodeableConcept;
+    unitOfMeasure?: `${EffectEvidenceSynthesisUnitOfMeasure}`;
     /** How precise the estimate is */
     precisionEstimate?: Array<EffectEvidenceSynthesisPrecisionEstimate>;
 }
@@ -150,14 +145,1444 @@ export interface EffectEvidenceSynthesisCertaintySubcomponent extends BackboneEl
     /** Used for footnotes or explanatory notes */
     note?: Array<Annotation>;
 }
-/** How certain is the effect */
-export interface EffectEvidenceSynthesisCertainty extends BackboneElement {
-    /** Certainty rating */
-    rating?: Array<CodeableConcept>;
-    /** Used for footnotes or explanatory notes */
-    note?: Array<Annotation>;
-    /** A component that contributes to the overall certainty */
-    certaintySubcomponent?: Array<EffectEvidenceSynthesisCertaintySubcomponent>;
+/** draft | active | retired | unknown */
+export declare enum EffectEvidenceSynthesisStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** How precise the estimate is */
+export interface EffectEvidenceSynthesisPrecisionEstimate extends BackboneElement {
+    /** Type of precision estimate */
+    type?: CodeableConcept;
+    /** Level of confidence interval */
+    level?: decimal;
+    _level?: Element;
+    /** Lower bound */
+    from?: decimal;
+    _from?: Element;
+    /** Upper bound */
+    to?: decimal;
+    _to?: Element;
+}
+/** exposure | exposure-alternative */
+export declare enum EffectEvidenceSynthesisExposureState {
+    Exposure = "exposure",
+    ExposureAlternative = "exposure-alternative"
+}
+/** What unit is the outcome described in? */
+export declare enum EffectEvidenceSynthesisUnitOfMeasure {
+    "Mo_j" = "mo_j",
+    CSt = "cSt",
+    "%{breakdown}" = "%{breakdown}",
+    "{rel_saturation}" = "{rel_saturation}",
+    "Fmol/g" = "fmol/g",
+    "{Pouches}/wk" = "{Pouches}/wk",
+    "Umol/mL" = "umol/mL",
+    "Kg/s" = "kg/s",
+    Bq = "Bq",
+    KPa = "kPa",
+    "Mosm/kg" = "mosm/kg",
+    "Mg/L" = "mg/L",
+    "Meq/kg" = "meq/kg",
+    "Nmol/(24.h)" = "nmol/(24.h)",
+    "U/mol" = "U/mol",
+    T = "T",
+    "K[IU]/mL" = "k[IU]/mL",
+    "B[V]" = "B[V]",
+    "Pmol/g" = "pmol/g",
+    "Num10*5" = "10*5",
+    Cm = "cm",
+    "{WhiteBloodCell}" = "{WhiteBloodCell}",
+    "{MPS'U}" = "{MPS'U}",
+    "Nmol/g{dry_wt}" = "nmol/g{dry_wt}",
+    Gf = "gf",
+    "{MPortionPhospholipids}" = "{M-PortionPhospholipids}",
+    "{titer}" = "{titer}",
+    "/g" = "/g",
+    "{Breaths}/min" = "{Breaths}/min",
+    "KU/mL" = "kU/mL",
+    "[rd_us]" = "[rd_us]",
+    "U{37Cel}/L" = "U{37Cel}/L",
+    "Pmol/H/mg{protein}" = "pmol/H/mg{protein}",
+    "[fth_us]" = "[fth_us]",
+    "Fmol/mg{cyt_prot}" = "fmol/mg{cyt_prot}",
+    "G/(kg.h)" = "g/(kg.h)",
+    "%{vol}" = "%{vol}",
+    "/{entity}" = "/{entity}",
+    "Mol/mol" = "mol/mol",
+    "Umol/h/g" = "umol/h/g",
+    Dm = "dm",
+    "[ston_av]" = "[ston_av]",
+    "G/g{Cre}" = "g/g{Cre}",
+    "%{Inhibition}" = "%{Inhibition}",
+    Mol = "mol",
+    "Pmol/h/mg{prot}" = "pmol/h/mg{prot}",
+    K = "K",
+    "{ComplementActivityEnzyme'U}" = "{ComplementActivityEnzyme'U}",
+    "%{WeightToWeight}" = "%{WeightToWeight}",
+    "%{bacteria}" = "%{bacteria}",
+    "Mg/(8.h.kg)" = "mg/(8.h.kg)",
+    "Cm[H2O]/(s.m)" = "cm[H2O]/(s.m)",
+    "[smi_us]" = "[smi_us]",
+    "Nmol/min" = "nmol/min",
+    "%{Bound}" = "%{Bound}",
+    "G/kg" = "g/kg",
+    Att = "att",
+    "Mg/L{RBCs}" = "mg/L{RBCs}",
+    "ML/(72.h)" = "mL/(72.h)",
+    "G.m/{hb}" = "g.m/{hb}",
+    "Ug/m2" = "ug/m2",
+    "Pmol/umol" = "pmol/umol",
+    "Meq/(kg.d)" = "meq/(kg.d)",
+    "Num10*3{Copies}/mL" = "10*3{Copies}/mL",
+    "Mg/kg/(24.h)" = "mg/kg/(24.h)",
+    "Mm[Hg]" = "mm[Hg]",
+    "Ug/dL{rbc}" = "ug/dL{rbc}",
+    "U/10*6" = "U/10*6",
+    "Ng/d" = "ng/d",
+    "[USP'U]" = "[USP'U]",
+    "Mmol/(2.h)" = "mmol/(2.h)",
+    "Num10.uN.s/(cm.m2)" = "10.uN.s/(cm.m2)",
+    "[in_us]" = "[in_us]",
+    Fmol = "fmol",
+    "Fmol/mg{protein}" = "fmol/mg{protein}",
+    "Nmol/L/mmol{creat}" = "nmol/L/mmol{creat}",
+    "[Btu]" = "[Btu]",
+    "Pmol/{RBC}" = "pmol/{RBC}",
+    "/10*3.{RBCs}" = "/10*3.{RBCs}",
+    "G/mmol{creat}" = "g/mmol{creat}",
+    "{AntibodyResponse'U}" = "{AntibodyResponse'U}",
+    "[IU]/kg" = "[IU]/kg",
+    "U/kg{hemoglobin}" = "U/kg{hemoglobin}",
+    "MU/mg" = "mU/mg",
+    "Cm[H2O]" = "cm[H2O]",
+    AU = "AU",
+    "Pg/{RBC}" = "pg/{RBC}",
+    "%{reactive}" = "%{reactive}",
+    "G/g{globulin}" = "g/g{globulin}",
+    "{cells}" = "{cells}",
+    "%{Live}" = "%{Live}",
+    "[pwt_tr]" = "[pwt_tr]",
+    "[ligne]" = "[ligne]",
+    "{IFA_index}" = "{IFA_index}",
+    "MU/mL/min" = "mU/mL/min",
+    "Num10*" = "10*",
+    "Pmol/min/mg{prot}" = "pmol/min/mg{prot}",
+    "[G]" = "[G]",
+    "ML/(24.h)" = "mL/(24.h)",
+    "[ka'U]" = "[ka'U]",
+    "G/L" = "g/L",
+    "/100" = "/100",
+    "Ng/mL{rbc}" = "ng/mL{rbc}",
+    st = "st",
+    "Umol/mol" = "umol/mol",
+    "Kat/L" = "kat/L",
+    "U/g{hemoglobin}" = "U/g{hemoglobin}",
+    "KU/L{class}" = "kU/L{class}",
+    "Pmol/mg{prot}" = "pmol/mg{prot}",
+    "Nmol/h/mg{protein}" = "nmol/h/mg{protein}",
+    "Num10*3{copies}/mL" = "10*3{copies}/mL",
+    "Mmol/h" = "mmol/h",
+    "[ppth]" = "[ppth]",
+    "{genomes}/mL" = "{genomes}/mL",
+    Mmol = "mmol",
+    Gon = "gon",
+    "Ng/dL/h" = "ng/dL/h",
+    "Mg/mmol" = "mg/mmol",
+    "Mg/mmol{Cre}" = "mg/mmol{Cre}",
+    "/100{neutrophils}" = "/100{neutrophils}",
+    "Mmol/(18.h)" = "mmol/(18.h)",
+    "Mmol/min" = "mmol/min",
+    "{spermatozoa}/mL" = "{spermatozoa}/mL",
+    "Mg/mg{Cre}" = "mg/mg{Cre}",
+    "Ng/kg/h" = "ng/kg/h",
+    "Ug/(kg.h)" = "ug/(kg.h)",
+    "{ToxoplasmaIndexValue}" = "{ToxoplasmaIndexValue}",
+    "/[IU]" = "/[IU]",
+    "/d" = "/d",
+    "Mg/(10.h)" = "mg/(10.h)",
+    "[cin_i]" = "[cin_i]",
+    "[oz_av]" = "[oz_av]",
+    "Ng/10*6" = "ng/10*6",
+    "%{HemoglobinA1C}" = "%{HemoglobinA1C}",
+    "{Ehrlich'U}/mL" = "{Ehrlich'U}/mL",
+    "{Applicator}" = "{Applicator}",
+    Pmol = "pmol",
+    "M[IU]/mL" = "m[IU]/mL",
+    "Mg/g{creat}" = "mg/g{creat}",
+    "U/mL" = "U/mL",
+    "[scwt_av]" = "[scwt_av]",
+    "[cicero]" = "[cicero]",
+    s = "s",
+    "Mmol/(5.h)" = "mmol/(5.h)",
+    "Pmol/h/mg{protein}" = "pmol/h/mg{protein}",
+    "{ElisaU}/mL" = "{ElisaU}/mL",
+    "Num10*12/L" = "10*12/L",
+    "G%" = "g%",
+    "Mol/mL" = "mol/mL",
+    "Meq/dL" = "meq/dL",
+    Lx = "lx",
+    "{Bottle}" = "{Bottle}",
+    "Nmol{ATP}" = "nmol{ATP}",
+    Lm = "lm",
+    "Ng/mL/h" = "ng/mL/h",
+    "Ug/g{Tissue}" = "ug/g{Tissue}",
+    "Umol/dL{GF}" = "umol/dL{GF}",
+    "/kg{body'wt}" = "/kg{body'wt}",
+    "{rbc}" = "{rbc}",
+    "Ug{T4}/dL" = "ug{T4}/dL",
+    "Umol/mmol" = "umol/mmol",
+    "Num10*3/uL" = "10*3/uL",
+    "{Log_copies}/mL" = "{Log_copies}/mL",
+    "Fmol/mg" = "fmol/mg",
+    "Lm/m2" = "lm/m2",
+    "%{blockade}" = "%{blockade}",
+    "Ug/mL{class}" = "ug/mL{class}",
+    "MU/min" = "mU/min",
+    Gy = "Gy",
+    "Num10*3" = "10*3",
+    "/[HPF]" = "/[HPF]",
+    "{M.o.M}" = "{M.o.M}",
+    "Pg/mL" = "pg/mL",
+    "{JDF'U}" = "{JDF'U}",
+    "A_t" = "a_t",
+    "Ug/g{Hgb}" = "ug/g{Hgb}",
+    "[sin_i]" = "[sin_i]",
+    "Pmol/h/mL" = "pmol/h/mL",
+    "U{25Cel}/L" = "U{25Cel}/L",
+    "Num10^" = "10^",
+    "{WBCs}" = "{WBCs}",
+    "{4 times}/d" = "{4 times}/d",
+    Ci = "Ci",
+    "Mg/g{tissue}" = "mg/g{tissue}",
+    "Ug/ng" = "ug/ng",
+    "[IU]/L{37Cel}" = "[IU]/L{37Cel}",
+    Pa = "Pa",
+    "{ERY}/uL" = "{ERY}/uL",
+    "Pmol/umol{creat}" = "pmol/umol{creat}",
+    "{binding_index}" = "{binding_index}",
+    MeV = "MeV",
+    "B[kW]" = "B[kW]",
+    "Mg/kg/d" = "mg/kg/d",
+    "/ug" = "/ug",
+    GBq = "GBq",
+    "Ug/(kg.d)" = "ug/(kg.d)",
+    "[tsp_us]" = "[tsp_us]",
+    "Mg/g{dry_tissue}" = "mg/g{dry_tissue}",
+    "/10*3" = "/10*3",
+    UOhm = "uOhm",
+    "ML/(8.h)" = "mL/(8.h)",
+    "/100{spermatozoa}" = "/100{spermatozoa}",
+    "Fmol/mL" = "fmol/mL",
+    "{# of fetuses}" = "{# of fetuses}",
+    "Ug/mL{eqv}" = "ug/mL{eqv}",
+    "{Packs}/d" = "{Packs}/d",
+    "[S]" = "[S]",
+    "G/min" = "g/min",
+    "Nmol/mol" = "nmol/mol",
+    MU = "mU",
+    Ug = "ug",
+    Ml = "ml",
+    "%[slope]" = "%[slope]",
+    "MU/mg{creat}" = "mU/mg{creat}",
+    "G.m/{beat}" = "g.m/{beat}",
+    "Num1/d" = "1/d",
+    "B[mV]" = "B[mV]",
+    MBq = "MBq",
+    UU = "uU",
+    "[PRU]" = "[PRU]",
+    "{Cells}/mL" = "{Cells}/mL",
+    "L/(min.m2)" = "L/(min.m2)",
+    "Ug/L" = "ug/L",
+    "Kg/m2" = "kg/m2",
+    "[smoot]" = "[smoot]",
+    "Ug/dL" = "ug/dL",
+    "[p'diop]" = "[p'diop]",
+    "Nmol/mg{prot}" = "nmol/mg{prot}",
+    "[ppm]" = "[ppm]",
+    "%{Total}" = "%{Total}",
+    "G/(24.h)" = "g/(24.h)",
+    "Num10*Num3{Polarization'U}" = "10*-3{Polarization'U}",
+    Pm = "pm",
+    "Umol/h/mg{protein}" = "umol/h/mg{protein}",
+    "G{total_prot}" = "g{total_prot}",
+    "/10*9" = "/10*9",
+    "/g{wet_tis}" = "/g{wet_tis}",
+    "%{inhibition}" = "%{inhibition}",
+    "/100{cells}" = "/100{cells}",
+    "Nmol/min/mg{prot}" = "nmol/min/mg{prot}",
+    "B[SPL]" = "B[SPL]",
+    "{Events}" = "{Events}",
+    "Ng/kg" = "ng/kg",
+    "[gal_br]" = "[gal_br]",
+    "/a" = "/a",
+    "Nmol/m/mg{prot}" = "nmol/m/mg{prot}",
+    "{#}/[LPF]" = "{#}/[LPF]",
+    "G/{total_weight}" = "g/{total_weight}",
+    "Nmol/mg{protein}" = "nmol/mg{protein}",
+    "[fdr_us]" = "[fdr_us]",
+    "Ug/mg" = "ug/mg",
+    "Ug/{specimen}" = "ug/{specimen}",
+    "U/(24.h)" = "U/(24.h)",
+    "Mmol/mmol" = "mmol/mmol",
+    "Mmol/kg/h" = "mmol/kg/h",
+    "Ug{FEU}/mL" = "ug{FEU}/mL",
+    ML = "mL",
+    "ML/[sin_i]" = "mL/[sin_i]",
+    "Num10*6/(24.h)" = "10*6/(24.h)",
+    "U/min" = "U/min",
+    "ML/d" = "mL/d",
+    "[APL'U]/mL" = "[APL'U]/mL",
+    "''" = "''",
+    "%{0to3Hours}" = "%{0to3Hours}",
+    "[lbf_av]" = "[lbf_av]",
+    "H/wk" = "h/wk",
+    "/10*12{RBCs}" = "/10*12{RBCs}",
+    "/h" = "/h",
+    "%{Hemolysis}" = "%{Hemolysis}",
+    "/kg" = "/kg",
+    "U/g{Hb}" = "U/g{Hb}",
+    "[MPL'U]" = "[MPL'U]",
+    "Mmol/mol{creat}" = "mmol/mol{creat}",
+    "Mg/g{wet_tissue}" = "mg/g{wet_tissue}",
+    "Umol/L{RBCs}" = "umol/L{RBCs}",
+    Rad = "rad",
+    Ueq = "ueq",
+    "Ohm.m" = "Ohm.m",
+    "{OpticalDensityIndex}" = "{OpticalDensityIndex}",
+    "Ng/(kg.h)" = "ng/(kg.h)",
+    "Mmol/kg/min" = "mmol/kg/min",
+    "Num10.L/(min.m2)" = "10.L/(min.m2)",
+    "%{BasalActivity}" = "%{BasalActivity}",
+    "[APL'U]" = "[APL'U]",
+    "[Btu_39]" = "[Btu_39]",
+    "Ng/mg" = "ng/mg",
+    "B[W]" = "B[W]",
+    DL = "dL",
+    "{CGG_repeats}" = "{CGG_repeats}",
+    "U/kg{Hb}" = "U/kg{Hb}",
+    "Mg/(kg.h)" = "mg/(kg.h)",
+    "Num10*9/mL" = "10*9/mL",
+    Nm = "nm",
+    "Ng/L" = "ng/L",
+    "{mutation}" = "{mutation}",
+    EV = "eV",
+    "[drp]/[HPF]" = "[drp]/[HPF]",
+    "%{response}" = "%{response}",
+    "/min" = "/min",
+    "/[LPF]" = "/[LPF]",
+    "[pca]" = "[pca]",
+    "[pk_us]" = "[pk_us]",
+    "{ComplementCH50'U}" = "{ComplementCH50'U}",
+    "Num10*6.[IU]" = "10*6.[IU]",
+    "M/s2" = "m/s2",
+    "{cells}/uL" = "{cells}/uL",
+    "%{WBCs}" = "%{WBCs}",
+    "Meq/g" = "meq/g",
+    "{3 times}/d" = "{3 times}/d",
+    "{GPortionPhospholipids}" = "{G-PortionPhospholipids}",
+    Umol = "umol",
+    "Fmol/L" = "fmol/L",
+    "Umol/mol{creat}" = "umol/mol{creat}",
+    "{Volume}/{Vvolume}" = "{Volume}/{Vvolume}",
+    Wb = "Wb",
+    "Nmol/min/mg{Hb}" = "nmol/min/mg{Hb}",
+    "{ARU}" = "{ARU}",
+    "ML/{beat}" = "mL/{beat}",
+    "{Dose}" = "{Dose}",
+    Ukat = "ukat",
+    Mm3 = "mm3",
+    "{Dalton}" = "{Dalton}",
+    L = "L",
+    "U/g{Cre}" = "U/g{Cre}",
+    "{#}" = "{#}",
+    mv = "mV",
+    "%{binding}" = "%{binding}",
+    "Nmol/mg{prot}/h" = "nmol/mg{prot}/h",
+    Mg = "mg",
+    "%{pooled_plasma}" = "%{pooled_plasma}",
+    "{OpticalDensity}" = "{OpticalDensity}",
+    "Ug/{TotalVolume}" = "ug/{TotalVolume}",
+    "%{NormalControl}" = "%{NormalControl}",
+    "{Log}" = "{Log}",
+    "[m_p]" = "[m_p]",
+    "%/100{WBC}" = "%/100{WBC}",
+    "Mg/{Specimen}" = "mg/{Specimen}",
+    "Kcal/kg/(24.h)" = "kcal/kg/(24.h)",
+    "Ug/mg{Cre}" = "ug/mg{Cre}",
+    "[LPF]" = "[LPF]",
+    M2 = "m2",
+    Num1 = "1",
+    Bit = "bit",
+    "{CPM}" = "{CPM}",
+    "Num10*6/L" = "10*6/L",
+    "Ug/g{DryWeight}" = "ug/g{DryWeight}",
+    "[hp_M]" = "[hp_M]",
+    "/10*6" = "/10*6",
+    "Ng{FEU}/mL" = "ng{FEU}/mL",
+    "{Package}" = "{Package}",
+    "Ueq/mL" = "ueq/mL",
+    "Mg/mmol{creat}" = "mg/mmol{creat}",
+    "Umol/g{creat}" = "umol/g{creat}",
+    "Mol/m3" = "mol/m3",
+    "MU/g{Hgb}" = "mU/g{Hgb}",
+    "Nmol/mmol{creat}" = "nmol/mmol{creat}",
+    "%{loss_AChR}" = "%{loss_AChR}",
+    "Umol/min/L" = "umol/min/L",
+    "Mol/L" = "mol/L",
+    Ky = "Ky",
+    "{Molecule}/{Platelet}" = "{Molecule}/{Platelet}",
+    "Mmol/dL" = "mmol/dL",
+    "Num10*3/L" = "10*3/L",
+    "Pg/mg{creat}" = "pg/mg{creat}",
+    "Meq/L" = "meq/L",
+    "%{hemolysis}" = "%{hemolysis}",
+    "G/(8.h){shift}" = "g/(8.h){shift}",
+    "[lk_br]" = "[lk_br]",
+    "L/s" = "L/s",
+    "L/min" = "L/min",
+    "U/g{creat}" = "U/g{creat}",
+    Mx = "Mx",
+    "%{Negative Control}" = "%{Negative Control}",
+    "NU/{RBC}" = "nU/{RBC}",
+    Erg = "erg",
+    "L/h" = "L/h",
+    "%{TotalProtein}" = "%{TotalProtein}",
+    "K[IU]/L" = "k[IU]/L",
+    "Mg/{Tot'Volume}" = "mg/{Tot'Volume}",
+    "%{abnormal}" = "%{abnormal}",
+    "[in_i'H2O]" = "[in_i'H2O]",
+    Ms = "Ms",
+    "{Tscore}" = "{Tscore}",
+    "Mmol/mol{Cre}" = "mmol/mol{Cre}",
+    "KU/h" = "kU/h",
+    "A/m" = "A/m",
+    "Ug/g{Cre}" = "ug/g{Cre}",
+    "[dr_ap]" = "[dr_ap]",
+    "{HaTiter}" = "{HaTiter}",
+    Kat = "kat",
+    "{copies}/mL" = "{copies}/mL",
+    "ML/min" = "mL/min",
+    "ML/(12.h)" = "mL/(12.h)",
+    "[hnsf'U]" = "[hnsf'U]",
+    "Num10*6/{Specimen}" = "10*6/{Specimen}",
+    "Ng/mg{protein}" = "ng/mg{protein}",
+    "/[iU]" = "/[iU]",
+    Hz = "Hz",
+    "{FIU}" = "{FIU}",
+    "[yd_br]" = "[yd_br]",
+    "{FluorescenceIntensity'U}" = "{FluorescenceIntensity'U}",
+    "{Rubella_virus}" = "{Rubella_virus}",
+    "{P2Y12 Reaction Units}" = "{P2Y12 Reaction Units}",
+    "%{Hemoglobin}" = "%{Hemoglobin}",
+    "[drp]/mL" = "[drp]/mL",
+    "[cyd_i]" = "[cyd_i]",
+    "[fur_us]" = "[fur_us]",
+    FL = "fL",
+    "ML/(4.h)" = "mL/(4.h)",
+    "{# of donor informative markers}" = "{# of donor informative markers}",
+    KV = "kV",
+    "Mg/m3" = "mg/m3",
+    "[pt_us]" = "[pt_us]",
+    "Ueq/L" = "ueq/L",
+    "%{ofAvailable}" = "%{ofAvailable}",
+    "{phenotype}" = "{phenotype}",
+    "[pc_br]" = "[pc_br]",
+    "G/mL" = "g/mL",
+    "[D'ag'U]" = "[D'ag'U]",
+    G = "G",
+    "Mg/kg/(8.h)" = "mg/kg/(8.h)",
+    "[HPF]" = "[HPF]",
+    Ps = "ps",
+    "L/s/s2" = "L/s/s2",
+    "Num10*6.eq/mL" = "10*6.eq/mL",
+    KBq = "kBq",
+    "Mg/d/{1.73_m2}" = "mg/d/{1.73_m2}",
+    "[AU]" = "[AU]",
+    Ao = "Ao",
+    "[drp]/h" = "[drp]/h",
+    "ML/(8.h)/kg" = "mL/(8.h)/kg",
+    "Mg/mg{creat}" = "mg/mg{creat}",
+    "Ug/L/(24.h)" = "ug/L/(24.h)",
+    "ML/mm" = "mL/mm",
+    "Nmol/L{RBCs}" = "nmol/L{RBCs}",
+    "[car_Au]" = "[car_Au]",
+    Dg = "dg",
+    Sr = "sr",
+    "%{normal}" = "%{normal}",
+    "/{oif}" = "/{oif}",
+    "{ElisaValue}" = "{ElisaValue}",
+    "Nmol{BCE}/mmol{creat}" = "nmol{BCE}/mmol{creat}",
+    "Mg/d" = "mg/d",
+    "[Btu_th]" = "[Btu_th]",
+    "[iU]/mL" = "[iU]/mL",
+    "{IndexValue}" = "{IndexValue}",
+    "[GPL'U]/mL" = "[GPL'U]/mL",
+    "{Ct}" = "{Ct}",
+    "{IFA_titer}" = "{IFA_titer}",
+    "Mg/{total_output}" = "mg/{total_output}",
+    "%{lysis}" = "%{lysis}",
+    "Mg/mg" = "mg/mg",
+    "{JuvenileDiabetesFound'U}" = "{JuvenileDiabetesFound'U}",
+    "{Each}" = "{Each}",
+    "[fth_br]" = "[fth_br]",
+    "MU/mmol{RBCs}" = "mU/mmol{RBCs}",
+    "{log_IU}/mL" = "{log_IU}/mL",
+    "Nmol/g{Cre}" = "nmol/g{Cre}",
+    "{Copies}/mL" = "{Copies}/mL",
+    "Cal_[15]" = "cal_[15]",
+    DB = "dB",
+    "[lb_tr]" = "[lb_tr]",
+    "L/d" = "L/d",
+    "[Btu_m]" = "[Btu_m]",
+    J = "J",
+    "MPa.s" = "mPa.s",
+    "[iU]" = "[iU]",
+    "Mmol/kg{H2O}" = "mmol/kg{H2O}",
+    "Mbar/L/s" = "mbar/L/s",
+    "{RubellaVirus}" = "{RubellaVirus}",
+    "Nmol/m/mg{protein}" = "nmol/m/mg{protein}",
+    "Pg/{cell}" = "pg/{cell}",
+    "Mg/wk" = "mg/wk",
+    "Mmol/g{hemoglobin}" = "mmol/g{hemoglobin}",
+    "[IU]/(2.h)" = "[IU]/(2.h)",
+    "{EIATiter}" = "{EIATiter}",
+    "{ISR}" = "{ISR}",
+    "Ng/mL{RBCs}" = "ng/mL{RBCs}",
+    "G/(48.h)" = "g/(48.h)",
+    "G/mg" = "g/mg",
+    "FL/nL" = "fL/nL",
+    "Nmol/g" = "nmol/g",
+    "[mu_0]" = "[mu_0]",
+    "/(12.h)" = "/(12.h)",
+    "[pi].rad/min" = "[pi].rad/min",
+    "Ug/kg" = "ug/kg",
+    "Pmol/min" = "pmol/min",
+    "[IU]/min" = "[IU]/min",
+    Ks = "ks",
+    "Mmol/m" = "mmol/m",
+    Ns = "ns",
+    "Kg{wet'tis}" = "kg{wet'tis}",
+    "Kg/h" = "kg/h",
+    "%{Blockade}" = "%{Blockade}",
+    "{minidrop}/s" = "{minidrop}/s",
+    "G/kg/d" = "g/kg/d",
+    "{KRONU'U}/mL" = "{KRONU'U}/mL",
+    "Mmol/{TotalVolume}" = "mmol/{TotalVolume}",
+    Mo = "mo",
+    "Mmol/(6.h)" = "mmol/(6.h)",
+    "{CAG_repeats}" = "{CAG_repeats}",
+    "J/L" = "J/L",
+    "{IgAAntiphosphatidyleserine'U}" = "{IgAAntiphosphatidyleserine'U}",
+    "[BAU]" = "[BAU]",
+    M = "m",
+    "Meq/(12.h)" = "meq/(12.h)",
+    Gal = "Gal",
+    "[fdr_br]" = "[fdr_br]",
+    "{CPM}/10*3{cell}" = "{CPM}/10*3{cell}",
+    "Nmol/mg{creat}" = "nmol/mg{creat}",
+    "Ug/h" = "ug/h",
+    "{GAA_repeats}" = "{GAA_repeats}",
+    "Ug/g{tissue}" = "ug/g{tissue}",
+    "[lk_us]" = "[lk_us]",
+    "Num10.uN.s/(cm5.m2)" = "10.uN.s/(cm5.m2)",
+    "Ug/{Specimen}" = "ug/{Specimen}",
+    "Mmol/kg/d" = "mmol/kg/d",
+    "{Bead}" = "{Bead}",
+    "G/{total_output}" = "g/{total_output}",
+    "KU/g" = "kU/g",
+    PT = "pT",
+    "/{tot}" = "/{tot}",
+    "Nmol/min/10*6{cells}" = "nmol/min/10*6{cells}",
+    "Kg/(s.m2)" = "kg/(s.m2)",
+    "{cfu}" = "{cfu}",
+    "ML/(kg.min)" = "mL/(kg.min)",
+    "ML/{h'b}" = "mL/{h'b}",
+    "[pi]" = "[pi]",
+    Oe = "Oe",
+    "UL/(2.h)" = "uL/(2.h)",
+    "UU/g" = "uU/g",
+    St = "St",
+    "/g{wet'tis}" = "/g{wet'tis}",
+    "{risk}" = "{risk}",
+    "{INR}" = "{INR}",
+    "Mg/mL" = "mg/mL",
+    "ML/(6.h)" = "mL/(6.h)",
+    "{count}" = "{count}",
+    "[acr_us]" = "[acr_us]",
+    "Ng/mg{prot}" = "ng/mg{prot}",
+    "Num10*6/uL" = "10*6/uL",
+    "{#}/d" = "{#}/d",
+    "{LymeIndexValue}" = "{LymeIndexValue}",
+    Mho = "mho",
+    "{index}" = "{index}",
+    "U/g{protein}" = "U/g{protein}",
+    "{#}/wk" = "{#}/wk",
+    "Umol/m" = "umol/m",
+    Sv = "Sv",
+    "[lb_av]" = "[lb_av]",
+    "Mol/mol{creat}" = "mol/mol{creat}",
+    "[lcwt_av]" = "[lcwt_av]",
+    "/g{tot_prot}" = "/g{tot_prot}",
+    "Ug/kg/d" = "ug/kg/d",
+    "{KRONU'U}/L" = "{KRONU'U}/L",
+    "[iU]/dL" = "[iU]/dL",
+    S = "S",
+    "{IgGAntiphosphatidyleserine'U}" = "{IgGAntiphosphatidyleserine'U}",
+    "Ug/g{hair}" = "ug/g{hair}",
+    "%{baseline}" = "%{baseline}",
+    "{EIA'U}/U" = "{EIA'U}/U",
+    "Umol/g{Cre}" = "umol/g{Cre}",
+    "L.s2/s" = "L.s2/s",
+    "[kn_i]" = "[kn_i]",
+    "G{creat}" = "g{creat}",
+    "[Btu_IT]" = "[Btu_IT]",
+    "Mg{creat}" = "mg{creat}",
+    "Ng/min" = "ng/min",
+    "Ug/mmol{creat}" = "ug/mmol{creat}",
+    "[min_br]" = "[min_br]",
+    "%{SpermMotility}" = "%{SpermMotility}",
+    "[in_i]" = "[in_i]",
+    "{Log_IU}/mL" = "{Log_IU}/mL",
+    "{Ehrlich'U}/100.g" = "{Ehrlich'U}/100.g",
+    "[drp]" = "[drp]",
+    "{Vial}" = "{Vial}",
+    "Mg/dL" = "mg/dL",
+    "Cm[H2O]/L/s" = "cm[H2O]/L/s",
+    "Nmol/umol{creat}" = "nmol/umol{creat}",
+    "{INR'unit}" = "{INR'unit}",
+    "[car_m]" = "[car_m]",
+    "/g{Hb}" = "/g{Hb}",
+    "{#}/min" = "{#}/min",
+    "U/umol" = "U/umol",
+    "{IgGIndex}" = "{IgGIndex}",
+    "ML/(5.h)" = "mL/(5.h)",
+    "{Pill}" = "{Pill}",
+    "[CFU]" = "[CFU]",
+    "{Cans}/wk" = "{Cans}/wk",
+    "[nmi_br]" = "[nmi_br]",
+    "Lm.m2" = "lm.m2",
+    "[nmi_i]" = "[nmi_i]",
+    H = "H",
+    "G/(8.h)" = "g/(8.h)",
+    "/m3" = "/m3",
+    "M2/s" = "m2/s",
+    Deg = "deg",
+    "Mg/(6.h)" = "mg/(6.h)",
+    "[gal_us]" = "[gal_us]",
+    "Cm[Hg]" = "cm[Hg]",
+    "ML/(2.h)" = "mL/(2.h)",
+    "/{Specimen}" = "/{Specimen}",
+    "Nmol/mg{protein}/h" = "nmol/mg{protein}/h",
+    "{CfTiter}" = "{CfTiter}",
+    "Meq/{total_volume}" = "meq/{total_volume}",
+    Mosm = "mosm",
+    "[PNU]" = "[PNU]",
+    Km = "km",
+    "Num10.uN.s/cm2" = "10.uN.s/cm2",
+    "[rd_br]" = "[rd_br]",
+    "%{OfWBCs}" = "%{OfWBCs}",
+    "%{Positive}" = "%{Positive}",
+    "{RecTiter}" = "{RecTiter}",
+    "/10*12{rbc}" = "/10*12{rbc}",
+    "Ug/mg{creat}" = "ug/mg{creat}",
+    "ML/mbar" = "mL/mbar",
+    "U/10" = "U/10",
+    "M[iU]" = "m[iU]",
+    "Umol/kg" = "umol/kg",
+    "H/d" = "h/d",
+    "{Can}" = "{Can}",
+    "Cm2/s" = "cm2/s",
+    "Dyn.s/cm" = "dyn.s/cm",
+    "{Ehrlich'U}/(2.h)" = "{Ehrlich'U}/(2.h)",
+    "Min/wk" = "min/wk",
+    "G/kg/(8.h)" = "g/kg/(8.h)",
+    "/mg" = "/mg",
+    "ML/s" = "mL/s",
+    "%{saturation}" = "%{saturation}",
+    Ph = "ph",
+    "L/kg" = "L/kg",
+    KU = "kU",
+    "{delta_OD}" = "{delta_OD}",
+    Um = "um",
+    "Um/s" = "um/s",
+    "[drp]/min" = "[drp]/min",
+    PA = "pA",
+    "[iU]/L" = "[iU]/L",
+    "[syd_i]" = "[syd_i]",
+    "Umol/mg" = "umol/mg",
+    "%{Uptake}" = "%{Uptake}",
+    "Ug/g" = "ug/g",
+    "{5 times}/d" = "{5 times}/d",
+    "MU/g{Hb}" = "mU/g{Hb}",
+    "Mg/h" = "mg/h",
+    "Num10.L/min" = "10.L/min",
+    "[tbs_us]" = "[tbs_us]",
+    "/mm3" = "/mm3",
+    "A_g" = "a_g",
+    "Umol/g{Hgb}" = "umol/g{Hgb}",
+    "G/g{tissue}" = "g/g{tissue}",
+    "%{total}" = "%{total}",
+    "{score}" = "{score}",
+    "G/mmol" = "g/mmol",
+    "[IU]/L" = "[IU]/L",
+    "Eq/L" = "eq/L",
+    "Meq/(8.h.kg)" = "meq/(8.h.kg)",
+    "Pmol/mL" = "pmol/mL",
+    "ML/kg/min" = "mL/kg/min",
+    "M/s" = "m/s",
+    "Pmol/mmol{creat}" = "pmol/mmol{creat}",
+    "Mo_s" = "mo_s",
+    "%" = "%",
+    Sph = "sph",
+    "G.m/{H.B.}" = "g.m/{H.B.}",
+    Kcal = "kcal",
+    "Mg/m2" = "mg/m2",
+    "{TSI_index}" = "{TSI_index}",
+    "[cup_us]" = "[cup_us]",
+    "N.cm" = "N.cm",
+    "U/10*12" = "U/10*12",
+    "{dilution}" = "{dilution}",
+    "Ug/mL" = "ug/mL",
+    "Mol/kg/s" = "mol/kg/s",
+    "Mg/{total_volume}" = "mg/{total_volume}",
+    "[Ch]" = "[Ch]",
+    "ML/{beat}/m2" = "mL/{beat}/m2",
+    "[IU]" = "[IU]",
+    "{Beats}/min" = "{Beats}/min",
+    "Umol/h" = "umol/h",
+    "{Times}/wk" = "{Times}/wk",
+    "Mm[H2O]" = "mm[H2O]",
+    "Fmol/mg{cytosol_protein}" = "fmol/mg{cytosol_protein}",
+    "%{bound}" = "%{bound}",
+    "[yd_i]" = "[yd_i]",
+    "Mg/kg/min" = "mg/kg/min",
+    R = "R",
+    "{Scoop}" = "{Scoop}",
+    "Ug/g{dry_wt}" = "ug/g{dry_wt}",
+    "{Tine'U}" = "{Tine'U}",
+    "{Elisa_U}/mL" = "{Elisa_U}/mL",
+    UCi = "uCi",
+    "U/mL{RBC}" = "U/mL{RBC}",
+    "[ft_us]" = "[ft_us]",
+    "[bu_br]" = "[bu_br]",
+    "[in_i'Hg]" = "[in_i'Hg]",
+    "Mg/{Hgb}/g" = "mg/{Hgb}/g",
+    "[dqt_us]" = "[dqt_us]",
+    C = "C",
+    "Mg{FEU}/L" = "mg{FEU}/L",
+    "Num10*3.{RBC}" = "10*3.{RBC}",
+    "B[uV]" = "B[uV]",
+    "[m_e]" = "[m_e]",
+    "{#}/a" = "{#}/a",
+    "Mmol/h/mg{prot}" = "mmol/h/mg{prot}",
+    ms = "ms",
+    "{breaths}/min" = "{breaths}/min",
+    "Eq/umol" = "eq/umol",
+    Wk = "wk",
+    "Meq/{Specimen}" = "meq/{Specimen}",
+    "Mmol/{total_vol}" = "mmol/{total_vol}",
+    "%{viable}" = "%{viable}",
+    "Umol/min" = "umol/min",
+    "Num24.h" = "24.h",
+    "[dpt_us]" = "[dpt_us]",
+    "Mmol/mol" = "mmol/mol",
+    "{GPS'U}" = "{GPS'U}",
+    "Meq/m2" = "meq/m2",
+    "U/(1.h)" = "U/(1.h)",
+    "/L" = "/L",
+    "/[arb'U]" = "/[arb'U]",
+    "[eps_0]" = "[eps_0]",
+    "U[IU]/mL" = "u[IU]/mL",
+    "Kcal/[oz_av]" = "kcal/[oz_av]",
+    F = "F",
+    "[ft_us]/[ft_us]" = "[ft_us]/[ft_us]",
+    "/dL" = "/dL",
+    "{STDV}" = "{STDV}",
+    "{ELISA'U}" = "{ELISA'U}",
+    "Cal_th" = "cal_th",
+    "G/d" = "g/d",
+    "U/10*9" = "U/10*9",
+    "MU/mg{Cre}" = "mU/mg{Cre}",
+    Circ = "circ",
+    "Nmol/h/mg{prot}" = "nmol/h/mg{prot}",
+    "[ft_br]" = "[ft_br]",
+    "M[H2O]" = "m[H2O]",
+    "%{Binding}" = "%{Binding}",
+    "/{Entity}" = "/{Entity}",
+    "{HA_titer}" = "{HA_titer}",
+    "G/(72.h)" = "g/(72.h)",
+    "[IU]/mg{creat}" = "[IU]/mg{creat}",
+    "L/(8.h)" = "L/(8.h)",
+    "/uL" = "/uL",
+    "UL/h" = "uL/h",
+    Pkat = "pkat",
+    "{percentile}" = "{percentile}",
+    "Pmol/(24.h)" = "pmol/(24.h)",
+    "Umol/d" = "umol/d",
+    "Mo_g" = "mo_g",
+    "Pmol/L" = "pmol/L",
+    "ML/min/(173.10*Num2.m2)" = "mL/min/(173.10*-2.m2)",
+    "[mil_us]" = "[mil_us]",
+    "{index_val}" = "{index_val}",
+    "{JDF'U}/L" = "{JDF'U}/L",
+    "UU/L" = "uU/L",
+    "[srd_us]" = "[srd_us]",
+    "Mg/kg/h" = "mg/kg/h",
+    "Num10*6/kg" = "10*6/kg",
+    "Mmol/{Tot'Volume}" = "mmol/{Tot'Volume}",
+    "Nmol/h/L" = "nmol/h/L",
+    "[IU]/g" = "[IU]/g",
+    "{Number}" = "{Number}",
+    "Kcal/(8.h)" = "kcal/(8.h)",
+    "MV/s" = "mV/s",
+    "%{residual}" = "%{residual}",
+    "Osm/kg" = "osm/kg",
+    "{KCT'U}" = "{KCT'U}",
+    "{ComplementCH100'U}" = "{ComplementCH100'U}",
+    "{minidrp}" = "{minidrp}",
+    "/10*10" = "/10*10",
+    "Nmol/min/mL" = "nmol/min/mL",
+    "Ng/U" = "ng/U",
+    B = "B",
+    "{IgMAntiphosphatidyleserine'U}" = "{IgMAntiphosphatidyleserine'U}",
+    "%{HumanResponse}" = "%{HumanResponse}",
+    "G/{TotalWeight}" = "g/{TotalWeight}",
+    "%{recovery}" = "%{recovery}",
+    "Nmol/s" = "nmol/s",
+    "MU/mmol{creatinine}" = "mU/mmol{creatinine}",
+    "/g{HGB}" = "/g{HGB}",
+    "U/10*10{cells}" = "U/10*10{cells}",
+    "{Streptozyme'U}" = "{Streptozyme'U}",
+    "%{penetration}" = "%{penetration}",
+    "/cm[H2O]" = "/cm[H2O]",
+    "Nmol/d" = "nmol/d",
+    "{IfaIndex}" = "{IfaIndex}",
+    "G{total_nit}" = "g{total_nit}",
+    "{Cells}/uL" = "{Cells}/uL",
+    a = "a",
+    "U/dL" = "U/dL",
+    "G/kg/(8.h){shift}" = "g/kg/(8.h){shift}",
+    "[IU]/kg/d" = "[IU]/kg/d",
+    "Ug/g{feces}" = "ug/g{feces}",
+    "{Count}" = "{Count}",
+    "Mmol/s/L" = "mmol/s/L",
+    "Num10*8" = "10*8",
+    "{Pan_Bio'U}" = "{Pan_Bio'U}",
+    "[didot]" = "[didot]",
+    "[bu_us]" = "[bu_us]",
+    "Ag/{cell}" = "ag/{cell}",
+    Cal = "cal",
+    "%{Abnormal}" = "%{Abnormal}",
+    "[qt_us]" = "[qt_us]",
+    "ML/dL" = "mL/dL",
+    "{#}/g" = "{#}/g",
+    "[diop]" = "[diop]",
+    "[PFU]" = "[PFU]",
+    "{copies}/ug" = "{copies}/ug",
+    "Kg/L" = "kg/L",
+    Torr = "Torr",
+    "Ug/mL{FEU}" = "ug/mL{FEU}",
+    "[IU]/d" = "[IU]/d",
+    "[dye'U]" = "[dye'U]",
+    "Eq/mL" = "eq/mL",
+    "Pmol/dL" = "pmol/dL",
+    Bd = "Bd",
+    "MU/g" = "mU/g",
+    "[hd_i]" = "[hd_i]",
+    "{mm/dd/yyyy}" = "{mm/dd/yyyy}",
+    "[pk_br]" = "[pk_br]",
+    "{# of informative markers}" = "{# of informative markers}",
+    Fg = "fg",
+    "Ug/kg/(8.h)" = "ug/kg/(8.h)",
+    MA = "mA",
+    "Umol/mg{Cre}" = "umol/mg{Cre}",
+    "Nmol{1/2cys}/mg{protein}" = "nmol{1/2cys}/mg{protein}",
+    "/10*12" = "/10*12",
+    "MU/g{protein}" = "mU/g{protein}",
+    "Mg/dL{RBCs}" = "mg/dL{RBCs}",
+    "[twp]" = "[twp]",
+    "[TCID_50]" = "[TCID_50]",
+    "[lb_ap]" = "[lb_ap]",
+    "{2 or 3 times}/d" = "{2 or 3 times}/d",
+    Osm = "osm",
+    "G/(3.d)" = "g/(3.d)",
+    "/100{WBCs}" = "/100{WBCs}",
+    "Umol/umol{creat}" = "umol/umol{creat}",
+    Cm2 = "cm2",
+    "U/mmol{creat}" = "U/mmol{creat}",
+    "G/(100.g)" = "g/(100.g)",
+    "Umol/(2.h)" = "umol/(2.h)",
+    "G/kg/min" = "g/kg/min",
+    "Nm/s/L" = "nm/s/L",
+    "Ng/h" = "ng/h",
+    "G/g{creat}" = "g/g{creat}",
+    "{EIA'U}" = "{EIA'U}",
+    "{Markers}" = "{Markers}",
+    "{Drinks}/d" = "{Drinks}/d",
+    "{Log_IU}" = "{Log_IU}",
+    "{CH100'U}" = "{CH100'U}",
+    "ML/({h'b}.m2)" = "mL/({h'b}.m2)",
+    "[iU]/g" = "[iU]/g",
+    "L/(24.h)" = "L/(24.h)",
+    "G/cm2" = "g/cm2",
+    "Ug/g{dry_tissue}" = "ug/g{dry_tissue}",
+    "Nmol/mg" = "nmol/mg",
+    "[drp]/s" = "[drp]/s",
+    "%{OfLymphocytes}" = "%{OfLymphocytes}",
+    "{copies}" = "{copies}",
+    "U/kg/h" = "U/kg/h",
+    UL = "uL",
+    "[mi_br]" = "[mi_br]",
+    "{clock_time}" = "{clock_time}",
+    "'" = "'",
+    "/m2" = "/m2",
+    "%{Carboxyhemoglobin}" = "%{Carboxyhemoglobin}",
+    "[hp_Q]" = "[hp_Q]",
+    "[c]" = "[c]",
+    "G.m/({hb}.m2)" = "g.m/({hb}.m2)",
+    "[mi_us]" = "[mi_us]",
+    "{RadioactiveT3UptakeRatio}" = "{RadioactiveT3UptakeRatio}",
+    "Umol/g{Hb}" = "umol/g{Hb}",
+    P = "P",
+    CP = "cP",
+    "[CCID_50]" = "[CCID_50]",
+    "{IfaTiter}" = "{IfaTiter}",
+    "[Amb'a'1'U]" = "[Amb'a'1'U]",
+    "Mg{Phenylketones}/dL" = "mg{Phenylketones}/dL",
+    "[gil_us]" = "[gil_us]",
+    "{ImmuneStatusRatio}" = "{ImmuneStatusRatio}",
+    "Umol/L{rbc}" = "umol/L{rbc}",
+    "[ly]" = "[ly]",
+    "Mmol/(12.h)" = "mmol/(12.h)",
+    "Meq/mL" = "meq/mL",
+    "[MPL'U]/mL" = "[MPL'U]/mL",
+    "Mmol/d" = "mmol/d",
+    "Meq/{specimen}" = "meq/{specimen}",
+    "[oz_tr]" = "[oz_tr]",
+    UV = "uV",
+    "[k]" = "[k]",
+    "Pg/mL{sLT}" = "pg/mL{sLT}",
+    "{DdTiter}" = "{DdTiter}",
+    "%{Index}" = "%{Index}",
+    "Nmol/min/mg{protein}" = "nmol/min/mg{protein}",
+    "{TmStp}" = "{TmStp}",
+    "DaL/min/m2" = "daL/min/m2",
+    "/g{creat}" = "/g{creat}",
+    "[rlk_us]" = "[rlk_us]",
+    "Ug/(100.g)" = "ug/(100.g)",
+    KL = "kL",
+    "{log_copies}/mL" = "{log_copies}/mL",
+    "Num10*6.[iU]" = "10*6.[iU]",
+    t = "t",
+    "Mg/{collection}" = "mg/{collection}",
+    Eq = "eq",
+    "U/s" = "U/s",
+    "G/(5.h)" = "g/(5.h)",
+    Us = "us",
+    "Mmol/L/s" = "mmol/L/s",
+    "Mg/{Volume}" = "mg/{Volume}",
+    "Mmol/(8.h.kg)" = "mmol/(8.h.kg)",
+    "Num10*3{RBCs}" = "10*3{RBCs}",
+    "M[Hg]" = "m[Hg]",
+    "NU/mL" = "nU/mL",
+    "[rch_us]" = "[rch_us]",
+    "Kcal/d" = "kcal/d",
+    "%{HemoglobinSaturation}" = "%{HemoglobinSaturation}",
+    "{Elisa'U}/mL" = "{Elisa'U}/mL",
+    "/wk" = "/wk",
+    "Cm/s" = "cm/s",
+    "[pnt_pr]" = "[pnt_pr]",
+    "G/(4.h)" = "g/(4.h)",
+    "{RBC}/uL" = "{RBC}/uL",
+    "[CFU]/mL" = "[CFU]/mL",
+    V = "V",
+    U = "U",
+    "MU/mmol{creat}" = "mU/mmol{creat}",
+    "Mg/{specimen}" = "mg/{specimen}",
+    "Num10.uN.s/cm" = "10.uN.s/cm",
+    "{ThyroxinUptake'U}" = "{ThyroxinUptake'U}",
+    Ohm = "Ohm",
+    "Eq/mmol" = "eq/mmol",
+    "[bbl_us]" = "[bbl_us]",
+    "D/wk" = "d/wk",
+    "G/g" = "g/g",
+    "{NonspecificOunce}" = "{NonspecificOunce}",
+    "Umol/g{hemoglobin}" = "umol/g{hemoglobin}",
+    "Nmol/mL/h" = "nmol/mL/h",
+    "Umol/10*6{RBC}" = "umol/10*6{RBC}",
+    "%{Cound}" = "%{Cound}",
+    Meq = "meq",
+    "ML{fetal_RBCs}" = "mL{fetal_RBCs}",
+    "[ch_us]" = "[ch_us]",
+    "{OpticalDensityRatio}" = "{OpticalDensityRatio}",
+    "G/cm3" = "g/cm3",
+    "{beats}/min" = "{beats}/min",
+    Bi = "Bi",
+    "[IU]/dL" = "[IU]/dL",
+    "G/h/m2" = "g/h/m2",
+    "Umol/g" = "umol/g",
+    "Mmol/kg" = "mmol/kg",
+    Cm3 = "cm3",
+    "ML/L" = "mL/L",
+    "[mclg'U]" = "[mclg'U]",
+    "Ug/L{RBCs}" = "ug/L{RBCs}",
+    Cd = "cd",
+    "{Ehrlich'U}/d" = "{Ehrlich'U}/d",
+    "[in_br]" = "[in_br]",
+    "{AHF'U}" = "{AHF'U}",
+    "[lton_av]" = "[lton_av]",
+    "[bf_i]" = "[bf_i]",
+    "/10*4{RBCs}" = "/10*4{RBCs}",
+    "Mg/(18.h)" = "mg/(18.h)",
+    "Min/d" = "min/d",
+    "[iU]/kg" = "[iU]/kg",
+    "{PackYears}" = "{PackYears}",
+    "Umol/mol{Cre}" = "umol/mol{Cre}",
+    "Mg/d/(173.10*Num2.m2)" = "mg/d/(173.10*-2.m2)",
+    "[tb'U]" = "[tb'U]",
+    "Dm2/s2" = "dm2/s2",
+    "U/10*10" = "U/10*10",
+    b = "b",
+    "ML/(10.h)" = "mL/(10.h)",
+    "Mmol/g" = "mmol/g",
+    "Ng/m2" = "ng/m2",
+    "Umol/mg{creat}" = "umol/mg{creat}",
+    "/{OIF}" = "/{OIF}",
+    "Nmol/L/s" = "nmol/L/s",
+    "[sft_i]" = "[sft_i]",
+    "/mL" = "/mL",
+    "%{ofBacteria}" = "%{ofBacteria}",
+    "[min_us]" = "[min_us]",
+    "Num10*6" = "10*6",
+    "/mo" = "/mo",
+    "Dyn.s/(cm.m2)" = "dyn.s/(cm.m2)",
+    "/100{WBC}" = "/100{WBC}",
+    "Ug/[sft_i]" = "ug/[sft_i]",
+    "{CGG}" = "{CGG}",
+    "[IU]/g{Hb}" = "[IU]/g{Hb}",
+    "Num10*Num6{Immunofluorescence'U}" = "10*-6{Immunofluorescence'U}",
+    "Ng/10*6{RBCs}" = "ng/10*6{RBCs}",
+    "[acr_br]" = "[acr_br]",
+    "Bit_s" = "bit_s",
+    MPa = "mPa",
+    "{StimulatingIndex}" = "{StimulatingIndex}",
+    "[arb'U]/mL" = "[arb'U]/mL",
+    "[knk'U]" = "[knk'U]",
+    Cel = "Cel",
+    "Pg/mm" = "pg/mm",
+    HL = "hL",
+    "UU/mL" = "uU/mL",
+    "Meq/(24.h)" = "meq/(24.h)",
+    "Mg/(8.h)" = "mg/(8.h)",
+    "{Percentile}" = "{Percentile}",
+    "{EhrlichU}/dL" = "{EhrlichU}/dL",
+    "%{positive}" = "%{positive}",
+    "{Absorbance'U}" = "{Absorbance'U}",
+    "[hp_C]" = "[hp_C]",
+    "G/(kg.min)" = "g/(kg.min)",
+    "{Once}/d" = "{Once}/d",
+    "{IgAPhospholipid'U}" = "{IgAPhospholipid'U}",
+    "{StandardIgM'U}" = "{StandardIgM'U}",
+    "G/(8.kg.h)" = "g/(8.kg.h)",
+    "Meq/kg/min" = "meq/kg/min",
+    "Mmol/h/mg{Hb}" = "mmol/h/mg{Hb}",
+    "K/W" = "K/W",
+    "Mg/(72.h)" = "mg/(72.h)",
+    "[FFU]" = "[FFU]",
+    "[arb'U]" = "[arb'U]",
+    Mbar = "mbar",
+    "U/g{Hgb}" = "U/g{Hgb}",
+    "{minidrop}/min" = "{minidrop}/min",
+    "Meq/g{creat}" = "meq/g{creat}",
+    "{#}/{platelet}" = "{#}/{platelet}",
+    "%{Tot'Hgb}" = "%{Tot'Hgb}",
+    "Ug/mmol" = "ug/mmol",
+    "Nmol/mg/h" = "nmol/mg/h",
+    "[ft_i]" = "[ft_i]",
+    g = "g",
+    "Mmol/g{creat}" = "mmol/g{creat}",
+    "Num10*4/uL" = "10*4/uL",
+    MCi = "mCi",
+    "[arb'U]/L" = "[arb'U]/L",
+    "Mm/min" = "mm/min",
+    "{Capsule}" = "{Capsule}",
+    "{StandardDeviation}" = "{StandardDeviation}",
+    "%{Tot'Cholesterol}" = "%{Tot'Cholesterol}",
+    "{ScoreOf}" = "{ScoreOf}",
+    "%{at_60_min}" = "%{at_60_min}",
+    "Mg/kg" = "mg/kg",
+    "Umol/umol" = "umol/umol",
+    "Meq/d" = "meq/d",
+    "ML/h" = "mL/h",
+    MV = "MV",
+    "Num10*6/mm3" = "10*6/mm3",
+    "Mg/min" = "mg/min",
+    By = "By",
+    "Nmol/min/mg{hemoglobin}" = "nmol/min/mg{hemoglobin}",
+    CL = "cL",
+    "Num10*3.U" = "10*3.U",
+    l = "l",
+    "%{Oxygen}" = "%{Oxygen}",
+    "U/g" = "U/g",
+    "{IgMIndex}" = "{IgMIndex}",
+    "Nmol/nmol" = "nmol/nmol",
+    "ML/kg/(8.h)" = "mL/kg/(8.h)",
+    "[smgy'U]" = "[smgy'U]",
+    "U[IU]" = "u[IU]",
+    "[gr]" = "[gr]",
+    "G/mol{creat}" = "g/mol{creat}",
+    N = "N",
+    "{StdDeviation'U}" = "{StdDeviation'U}",
+    NL = "nL",
+    "Cm[H2O]/s/m" = "cm[H2O]/s/m",
+    "Nmol{BCE}/L" = "nmol{BCE}/L",
+    "/U" = "/U",
+    "Mol/s" = "mol/s",
+    "Nmol/mL/min" = "nmol/mL/min",
+    "Mm/h" = "mm/h",
+    "{s_co_ratio}" = "{s_co_ratio}",
+    "%{Fat}" = "%{Fat}",
+    "{kp_C}" = "{kp_C}",
+    u = "u",
+    "{spray}" = "{spray}",
+    "Mmol/L{RBCs}" = "mmol/L{RBCs}",
+    "[crd_us]" = "[crd_us]",
+    "Cal_[20]" = "cal_[20]",
+    "{lgCopies}/ml" = "{lgCopies}/ml",
+    "/g{tot'prot}" = "/g{tot'prot}",
+    "[GPL'U]" = "[GPL'U]",
+    "Ug/kg/h" = "ug/kg/h",
+    "Mg/(2.h)" = "mg/(2.h)",
+    "{fraction}" = "{fraction}",
+    "/g{tot'nit}" = "/g{tot'nit}",
+    "Nmol/h/mL" = "nmol/h/mL",
+    "{Ct_value}" = "{Ct_value}",
+    "Nmol/L" = "nmol/L",
+    "Kcal/(24.h)" = "kcal/(24.h)",
+    "Meq/min" = "meq/min",
+    "Umol/dL" = "umol/dL",
+    "[IU]/(24.h)" = "[IU]/(24.h)",
+    "[gal_wi]" = "[gal_wi]",
+    "[iU]/g{Hgb}" = "[iU]/g{Hgb}",
+    "Pg/L" = "pg/L",
+    "{molecule}/{platelet}" = "{molecule}/{platelet}",
+    "Umol/min/g{protein}" = "umol/min/g{protein}",
+    "Ug/(24.h)" = "ug/(24.h)",
+    "%{deficient}" = "%{deficient}",
+    A = "A",
+    "Mmol/kg/(8.h)" = "mmol/kg/(8.h)",
+    "[pt_br]" = "[pt_br]",
+    "{clock time}" = "{clock time}",
+    "Ng/g{Cre}" = "ng/g{Cre}",
+    "{OD_unit}" = "{OD_unit}",
+    "{CagRepeat}" = "{CagRepeat}",
+    "%{NormalPooledPlasma}" = "%{NormalPooledPlasma}",
+    "[Btu_59]" = "[Btu_59]",
+    "Mol/d" = "mol/d",
+    "Mg/g" = "mg/g",
+    "Mg/(24.h)" = "mg/(24.h)",
+    Nmol = "nmol",
+    "Nmol/mL" = "nmol/mL",
+    "Ng/(8.h)" = "ng/(8.h)",
+    "Ug/g{creat}" = "ug/g{creat}",
+    "{#}/[HPF]" = "{#}/[HPF]",
+    "Mg/g{Cre}" = "mg/g{Cre}",
+    "%{FetalErythrocytes}" = "%{FetalErythrocytes}",
+    "Nmol/dL{GF}" = "nmol/dL{GF}",
+    "{Absorbance'U}/mL" = "{Absorbance'U}/mL",
+    "{ratio}" = "{ratio}",
+    "Kg.m/s" = "kg.m/s",
+    "{EIAIndex}" = "{EIAIndex}",
+    "/mm" = "/mm",
+    "{tot}" = "{tot}",
+    "Umol/mL/min" = "umol/mL/min",
+    "Nmol/dL" = "nmol/dL",
+    "Pmol/mg{protein}" = "pmol/mg{protein}",
+    "%{EosSeen}" = "%{EosSeen}",
+    "Ng/dL" = "ng/dL",
+    "G/mol" = "g/mol",
+    "Ng/mg{creat}" = "ng/mg{creat}",
+    "/g{hgb}" = "/g{hgb}",
+    Gb = "Gb",
+    "Umol/h/L" = "umol/h/L",
+    "%{normal_pooled_plasma}" = "%{normal_pooled_plasma}",
+    "Nmol/s/L" = "nmol/s/L",
+    "Meq/kg/h" = "meq/kg/h",
+    "Ug/g{Hb}" = "ug/g{Hb}",
+    "/g{tot_nit}" = "/g{tot_nit}",
+    "Umol/min/g" = "umol/min/g",
+    "{EIA_titer}" = "{EIA_titer}",
+    "[kn_br]" = "[kn_br]",
+    "Pmol/d" = "pmol/d",
+    "{tbl}" = "{tbl}",
+    "%{Hb}" = "%{Hb}",
+    "Umol/L/h" = "umol/L/h",
+    "%{loss}" = "%{loss}",
+    "Mol/kg" = "mol/kg",
+    "{Ehrlich_U}/dL" = "{Ehrlich_U}/dL",
+    "G{wet_tissue}" = "g{wet_tissue}",
+    "[sct]" = "[sct]",
+    "Ng/(kg.d)" = "ng/(kg.d)",
+    "{Counts}/min" = "{Counts}/min",
+    "Umol/kg{feces}" = "umol/kg{feces}",
+    "[psi]" = "[psi]",
+    "U/10*12{RBCs}" = "U/10*12{RBCs}",
+    "/mmol" = "/mmol",
+    "{SatIndex}" = "{SatIndex}",
+    "Ug/(8.h)" = "ug/(8.h)",
+    "G/kg/h" = "g/kg/h",
+    "{saturation}" = "{saturation}",
+    "{CAE'U}" = "{CAE'U}",
+    "[stone_av]" = "[stone_av]",
+    "U/mL{RBCs}" = "U/mL{RBCs}",
+    "Num10*9/L" = "10*9/L",
+    "Kcal/h" = "kcal/h",
+    RAD = "RAD",
+    "Mosm/L" = "mosm/L",
+    "Pmol/min/mg{protein}" = "pmol/min/mg{protein}",
+    "Num10*6/mL" = "10*6/mL",
+    "M3/s" = "m3/s",
+    "Meq/h" = "meq/h",
+    "{M.o.M.}" = "{M.o.M.}",
+    "[pnt]" = "[pnt]",
+    "{MultOfMean}" = "{MultOfMean}",
+    "Kat/kg" = "kat/kg",
+    "%{Normal}" = "%{Normal}",
+    "{RPI'U}" = "{RPI'U}",
+    "{APS'U}" = "{APS'U}",
+    "Mmol/{specimen}" = "mmol/{specimen}",
+    "Nmol/mol{creat}" = "nmol/mol{creat}",
+    h = "h",
+    "/mmol{creat}" = "/mmol{creat}",
+    "{StandardIgA'U}" = "{StandardIgA'U}",
+    "{RelativeViscosity}" = "{RelativeViscosity}",
+    "Pg/mg" = "pg/mg",
+    "U/(10.g){feces}" = "U/(10.g){feces}",
+    "Ng/(8.h.kg)" = "ng/(8.h.kg)",
+    Lmb = "Lmb",
+    "Mmol/L" = "mmol/L",
+    "[ppb]" = "[ppb]",
+    "ML/kg/h" = "mL/kg/h",
+    "Pmol/mol" = "pmol/mol",
+    "[CFU]/L" = "[CFU]/L",
+    "[IU]/10*9{RBCs}" = "[IU]/10*9{RBCs}",
+    "Ng/s" = "ng/s",
+    "[h]" = "[h]",
+    "G/(12.h)" = "g/(12.h)",
+    "{Copies}/uL" = "{Copies}/uL",
+    "Fmol/mg{prot}" = "fmol/mg{prot}",
+    "[pptr]" = "[pptr]",
+    "Ug/dL{RBCs}" = "ug/dL{RBCs}",
+    Atm = "atm",
+    "{Cell}" = "{Cell}",
+    "Mg/{TotalVolume}" = "mg/{TotalVolume}",
+    NCi = "nCi",
+    "[bdsk'U]" = "[bdsk'U]",
+    "Ug/min" = "ug/min",
+    "Num1/min" = "1/min",
+    "Ng/g" = "ng/g",
+    "{Patch}" = "{Patch}",
+    "%{Activity}" = "%{Activity}",
+    "[foz_br]" = "[foz_br]",
+    "A_j" = "a_j",
+    "Ng/g{creat}" = "ng/g{creat}",
+    "{#}/L" = "{#}/L",
+    "Ng/mL" = "ng/mL",
+    "ML/m2" = "mL/m2",
+    "[pied]" = "[pied]",
+    "{Immunity}" = "{Immunity}",
+    "Num10*6.[CFU]/L" = "10*6.[CFU]/L",
+    "D/(7.d)" = "d/(7.d)",
+    "{Relative'U}" = "{Relative'U}",
+    "Mmol/m2" = "mmol/m2",
+    "Mg/mg{cre}" = "mg/mg{cre}",
+    "U/(2.h)" = "U/(2.h)",
+    "Ug/d" = "ug/d",
+    "[ppm]{v/v}" = "[ppm]{v/v}",
+    REM = "REM",
+    "Nmol/mmol" = "nmol/mmol",
+    "Nmol{BCE}" = "nmol{BCE}",
+    "[gil_br]" = "[gil_br]",
+    "[Lf]" = "[Lf]",
+    "{shift}" = "{shift}",
+    "/10*3{RBCs}" = "/10*3{RBCs}",
+    "ML/min/{1.73_m2}" = "mL/min/{1.73_m2}",
+    Ar = "ar",
+    "G/(6.h)" = "g/(6.h)",
+    "{MPS'U}/mL" = "{MPS'U}/mL",
+    "G/dL" = "g/dL",
+    "U/(12.h)" = "U/(12.h)",
+    Kg = "kg",
+    "%{blocked}" = "%{blocked}",
+    "Umol/(8.h)" = "umol/(8.h)",
+    "Num10*9/uL" = "10*9/uL",
+    "Mmol/h/mg{protein}" = "mmol/h/mg{protein}",
+    "%{uptake}" = "%{uptake}",
+    "[pca_pr]" = "[pca_pr]",
+    "%{reference}" = "%{reference}",
+    Cg = "cg",
+    "{#}/mL" = "{#}/mL",
+    "{absorbance}" = "{absorbance}",
+    "[sc_ap]" = "[sc_ap]",
+    "ML/min/m2" = "mL/min/m2",
+    "%{Precipitate}" = "%{Precipitate}",
+    "Osm/L" = "osm/L",
+    "Umol/min/g{prot}" = "umol/min/g{prot}",
+    "Ug/m3" = "ug/m3",
+    "{Ehrlich'U}" = "{Ehrlich'U}",
+    "U/L" = "U/L",
+    "/s" = "/s",
+    "[e]" = "[e]",
+    "[fth_i]" = "[fth_i]",
+    "{Globules}/[HPF]" = "{Globules}/[HPF]",
+    "Ng/(24.h)" = "ng/(24.h)",
+    Pc = "pc",
+    "{InhaledTobaccoUseAmountYears}" = "{InhaledTobaccoUseAmountYears}",
+    "Mmol/mmol{urea}" = "mmol/mmol{urea}",
+    Sb = "sb",
+    "%{index}" = "%{index}",
+    Mm = "mm",
+    "Num10*6.U" = "10*6.U",
+    "Pmol/mmol" = "pmol/mmol",
+    "[ch_br]" = "[ch_br]",
+    "DaL/min" = "daL/min",
+    "[MET]" = "[MET]",
+    "{activity}" = "{activity}",
+    "[cml_i]" = "[cml_i]",
+    "Mmol/(8.h)" = "mmol/(8.h)",
+    "{Lyme_index_value}" = "{Lyme_index_value}",
+    "Mmol/{ejaculate}" = "mmol/{ejaculate}",
+    "{Dilution}" = "{Dilution}",
+    "ML/kg/d" = "mL/kg/d",
+    Bar = "bar",
+    W = "W",
+    "G/{specimen}" = "g/{specimen}",
+    "[qt_br]" = "[qt_br]",
+    "Ng/mg/h" = "ng/mg/h",
+    Np = "Np",
+    "N.s" = "N.s",
+    "[mi_i]" = "[mi_i]",
+    "Umol/L" = "umol/L",
+    "U/(18.h)" = "U/(18.h)",
+    "{cells}/[HPF]" = "{cells}/[HPF]",
+    "%{Excretion}" = "%{Excretion}",
+    "[foz_us]" = "[foz_us]",
+    "Nmol/g{creat}" = "nmol/g{creat}",
+    "{StandardIgG'U}" = "{StandardIgG'U}",
+    "[Btu_60]" = "[Btu_60]",
+    "{InhaledTobaccoUsePacks}/d" = "{InhaledTobaccoUsePacks}/d",
+    "G/h" = "g/h",
+    Min = "min",
+    Pg = "pg",
+    "{ElisaIndex}" = "{ElisaIndex}",
+    "%{basal_activity}" = "%{basal_activity}",
+    "G{Hb}" = "g{Hb}",
+    "{Zscore}" = "{Zscore}",
+    "Pg/dL" = "pg/dL",
+    "Cal_IT" = "cal_IT",
+    "%{cells}" = "%{cells}",
+    "G/m2" = "g/m2",
+    "%{Conversion}" = "%{Conversion}",
+    "[cft_i]" = "[cft_i]",
+    "Meq/(8.h)" = "meq/(8.h)",
+    "%{aggregation}" = "%{aggregation}",
+    "L/min/m2" = "L/min/m2",
+    "%{relative}" = "%{relative}",
+    "{Disintegrations}/min" = "{Disintegrations}/min",
+    "[mil_i]" = "[mil_i]",
+    "Ug/L{DDU}" = "ug/L{DDU}",
+    "{ImmuneComplex'U}" = "{ImmuneComplex'U}",
+    "%{Reactivity}" = "%{Reactivity}",
+    "U{G}" = "U{G}",
+    "[yd_us]" = "[yd_us]",
+    "Umol/(24.h)" = "umol/(24.h)",
+    "Ng/kg/min" = "ng/kg/min",
+    "%{activity}" = "%{activity}",
+    "[todd'U]" = "[todd'U]",
+    "Umol/mmol{creat}" = "umol/mmol{creat}",
+    "[HP]" = "[HP]",
+    "{Bowls}/d" = "{Bowls}/d",
+    D = "d",
+    Nkat = "nkat",
+    "[oz_ap]" = "[oz_ap]",
+    "Meq/(2.h)" = "meq/(2.h)",
+    "{#}/uL" = "{#}/uL",
+    "K[iU]/mL" = "k[iU]/mL",
+    "[pouce]" = "[pouce]",
+    "/kg{body_wt}" = "/kg{body_wt}",
+    "[Cal]" = "[Cal]",
+    "Meq/g{Cre}" = "meq/g{Cre}",
+    "%{risk}" = "%{risk}",
+    "[degF]" = "[degF]",
+    "ML/kg" = "mL/kg",
+    "U/h" = "U/h",
+    "G.m" = "g.m",
+    "MU/g{prot}" = "mU/g{prot}",
+    "M[IU]/L" = "m[IU]/L",
+    "{# of calculi}" = "{# of calculi}",
+    "%{dose}" = "%{dose}",
+    "{TIBC'U}" = "{TIBC'U}",
+    "{relative_saturation}" = "{relative_saturation}",
+    "Kg/min" = "kg/min",
+    "MU/L" = "mU/L",
+    "{Ehrlich'U}/dL" = "{Ehrlich'U}/dL",
+    "[cr_i]" = "[cr_i]",
+    "[beth'U]" = "[beth'U]",
+    "{yyyy}" = "{yyyy}",
+    "[hp_X]" = "[hp_X]",
+    "Mmol/(24.h)" = "mmol/(24.h)",
+    "{Spermatozoa}/mL" = "{Spermatozoa}/mL",
+    "Mbar.s/L" = "mbar.s/L",
+    "Ng/mg{Protein}" = "ng/mg{Protein}",
+    "/100{Spermatozoa}" = "/100{Spermatozoa}",
+    "{EV}" = "{EV}",
+    "MU/mL" = "mU/mL",
+    "Mg/(12.h)" = "mg/(12.h)",
+    "[MET].min/wk" = "[MET].min/wk",
+    "{AspirinReaction'U}" = "{AspirinReaction'U}",
+    "Kg/mol" = "kg/mol",
+    "{cfu}/mL" = "{cfu}/mL",
+    "Kg/m3" = "kg/m3",
+    Mm2 = "mm2",
+    "Umol/mol{Hb}" = "umol/mol{Hb}",
+    "ML/cm[H2O]" = "mL/cm[H2O]",
+    "{EIA_index}" = "{EIA_index}",
+    "U/d" = "U/d",
+    Fm = "fm",
+    "Cal_m" = "cal_m",
+    "KU/L" = "kU/L",
+    "S/{control}" = "s/{control}",
+    "Umol{BCE}/mol" = "umol{BCE}/mol",
+    "{GliadinIndexValue}" = "{GliadinIndexValue}",
+    "Ng/(kg.min)" = "ng/(kg.min)",
+    "{Index_val}" = "{Index_val}",
+    "[IU]/mL" = "[IU]/mL",
+    "Ug/kg/min" = "ug/kg/min",
+    "Deg/s" = "deg/s",
+    "U[IU]/L" = "u[IU]/L",
+    "Mmol/mmol{creat}" = "mmol/mmol{creat}",
+    "Umol/min/g{mucosa}" = "umol/min/g{mucosa}",
+    "{DeltaOpticalDensity}" = "{DeltaOpticalDensity}",
+    "{WeeksDays}" = "{WeeksDays}",
+    "[pH]" = "[pH]",
+    Dyn = "dyn",
+    Ng = "ng",
+    "%{RBCs}" = "%{RBCs}",
+    "Ng/kg/(8.h)" = "ng/kg/(8.h)",
+    "[IU]/h" = "[IU]/h",
+    "[mesh_i]" = "[mesh_i]",
+    "[lne]" = "[lne]",
+    "Mg/g{feces}" = "mg/g{feces}",
+    "[dr_av]" = "[dr_av]",
+    "{ActivityCoefficient}" = "{ActivityCoefficient}",
+    "Nmol/mmol{Cre}" = "nmol/mmol{Cre}",
+    "%{excretion}" = "%{excretion}",
+    "L/L" = "L/L",
+    "Num10*3/mL" = "10*3/mL",
+    PL = "pL"
 }
 /** What was the result per exposure? */
 export interface EffectEvidenceSynthesisResultsByExposure extends BackboneElement {
@@ -165,10 +1590,10 @@ export interface EffectEvidenceSynthesisResultsByExposure extends BackboneElemen
     description?: string;
     _description?: Element;
     /** exposure | exposure-alternative */
-    exposureState?: code;
+    exposureState?: `${EffectEvidenceSynthesisExposureState}`;
     _exposureState?: Element;
     /** Variant exposure states */
     variantState?: CodeableConcept;
     /** Risk evidence synthesis */
-    riskEvidenceSynthesis: Reference<"RiskEvidenceSynthesis">;
+    riskEvidenceSynthesis: Reference<'RiskEvidenceSynthesis'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/EffectEvidenceSynthesis.js b/vendor/r4/types/hl7-fhir-r4-core/EffectEvidenceSynthesis.js
index c8ad2e5..c87378b 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/EffectEvidenceSynthesis.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/EffectEvidenceSynthesis.js
@@ -1,2 +1,1431 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectEvidenceSynthesisUnitOfMeasure = exports.EffectEvidenceSynthesisExposureState = exports.EffectEvidenceSynthesisStatus = void 0;
+/** draft | active | retired | unknown */
+var EffectEvidenceSynthesisStatus;
+(function (EffectEvidenceSynthesisStatus) {
+    EffectEvidenceSynthesisStatus["Active"] = "active";
+    EffectEvidenceSynthesisStatus["Draft"] = "draft";
+    EffectEvidenceSynthesisStatus["Retired"] = "retired";
+    EffectEvidenceSynthesisStatus["Unknown"] = "unknown";
+})(EffectEvidenceSynthesisStatus = exports.EffectEvidenceSynthesisStatus || (exports.EffectEvidenceSynthesisStatus = {}));
+/** exposure | exposure-alternative */
+var EffectEvidenceSynthesisExposureState;
+(function (EffectEvidenceSynthesisExposureState) {
+    EffectEvidenceSynthesisExposureState["Exposure"] = "exposure";
+    EffectEvidenceSynthesisExposureState["ExposureAlternative"] = "exposure-alternative";
+})(EffectEvidenceSynthesisExposureState = exports.EffectEvidenceSynthesisExposureState || (exports.EffectEvidenceSynthesisExposureState = {}));
+/** What unit is the outcome described in? */
+var EffectEvidenceSynthesisUnitOfMeasure;
+(function (EffectEvidenceSynthesisUnitOfMeasure) {
+    EffectEvidenceSynthesisUnitOfMeasure["Mo_j"] = "mo_j";
+    EffectEvidenceSynthesisUnitOfMeasure["CSt"] = "cSt";
+    EffectEvidenceSynthesisUnitOfMeasure["%{breakdown}"] = "%{breakdown}";
+    EffectEvidenceSynthesisUnitOfMeasure["{rel_saturation}"] = "{rel_saturation}";
+    EffectEvidenceSynthesisUnitOfMeasure["Fmol/g"] = "fmol/g";
+    EffectEvidenceSynthesisUnitOfMeasure["{Pouches}/wk"] = "{Pouches}/wk";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/mL"] = "umol/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Kg/s"] = "kg/s";
+    EffectEvidenceSynthesisUnitOfMeasure["Bq"] = "Bq";
+    EffectEvidenceSynthesisUnitOfMeasure["KPa"] = "kPa";
+    EffectEvidenceSynthesisUnitOfMeasure["Mosm/kg"] = "mosm/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/L"] = "mg/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/kg"] = "meq/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/(24.h)"] = "nmol/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["U/mol"] = "U/mol";
+    EffectEvidenceSynthesisUnitOfMeasure["T"] = "T";
+    EffectEvidenceSynthesisUnitOfMeasure["K[IU]/mL"] = "k[IU]/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["B[V]"] = "B[V]";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/g"] = "pmol/g";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*5"] = "10*5";
+    EffectEvidenceSynthesisUnitOfMeasure["Cm"] = "cm";
+    EffectEvidenceSynthesisUnitOfMeasure["{WhiteBloodCell}"] = "{WhiteBloodCell}";
+    EffectEvidenceSynthesisUnitOfMeasure["{MPS'U}"] = "{MPS'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/g{dry_wt}"] = "nmol/g{dry_wt}";
+    EffectEvidenceSynthesisUnitOfMeasure["Gf"] = "gf";
+    EffectEvidenceSynthesisUnitOfMeasure["{MPortionPhospholipids}"] = "{M-PortionPhospholipids}";
+    EffectEvidenceSynthesisUnitOfMeasure["{titer}"] = "{titer}";
+    EffectEvidenceSynthesisUnitOfMeasure["/g"] = "/g";
+    EffectEvidenceSynthesisUnitOfMeasure["{Breaths}/min"] = "{Breaths}/min";
+    EffectEvidenceSynthesisUnitOfMeasure["KU/mL"] = "kU/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["[rd_us]"] = "[rd_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["U{37Cel}/L"] = "U{37Cel}/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/H/mg{protein}"] = "pmol/H/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["[fth_us]"] = "[fth_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Fmol/mg{cyt_prot}"] = "fmol/mg{cyt_prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(kg.h)"] = "g/(kg.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["%{vol}"] = "%{vol}";
+    EffectEvidenceSynthesisUnitOfMeasure["/{entity}"] = "/{entity}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mol/mol"] = "mol/mol";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/h/g"] = "umol/h/g";
+    EffectEvidenceSynthesisUnitOfMeasure["Dm"] = "dm";
+    EffectEvidenceSynthesisUnitOfMeasure["[ston_av]"] = "[ston_av]";
+    EffectEvidenceSynthesisUnitOfMeasure["G/g{Cre}"] = "g/g{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Inhibition}"] = "%{Inhibition}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mol"] = "mol";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/h/mg{prot}"] = "pmol/h/mg{prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["K"] = "K";
+    EffectEvidenceSynthesisUnitOfMeasure["{ComplementActivityEnzyme'U}"] = "{ComplementActivityEnzyme'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{WeightToWeight}"] = "%{WeightToWeight}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{bacteria}"] = "%{bacteria}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/(8.h.kg)"] = "mg/(8.h.kg)";
+    EffectEvidenceSynthesisUnitOfMeasure["Cm[H2O]/(s.m)"] = "cm[H2O]/(s.m)";
+    EffectEvidenceSynthesisUnitOfMeasure["[smi_us]"] = "[smi_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/min"] = "nmol/min";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Bound}"] = "%{Bound}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/kg"] = "g/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["Att"] = "att";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/L{RBCs}"] = "mg/L{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/(72.h)"] = "mL/(72.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["G.m/{hb}"] = "g.m/{hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/m2"] = "ug/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/umol"] = "pmol/umol";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/(kg.d)"] = "meq/(kg.d)";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*3{Copies}/mL"] = "10*3{Copies}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/kg/(24.h)"] = "mg/kg/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Mm[Hg]"] = "mm[Hg]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/dL{rbc}"] = "ug/dL{rbc}";
+    EffectEvidenceSynthesisUnitOfMeasure["U/10*6"] = "U/10*6";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/d"] = "ng/d";
+    EffectEvidenceSynthesisUnitOfMeasure["[USP'U]"] = "[USP'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/(2.h)"] = "mmol/(2.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10.uN.s/(cm.m2)"] = "10.uN.s/(cm.m2)";
+    EffectEvidenceSynthesisUnitOfMeasure["[in_us]"] = "[in_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Fmol"] = "fmol";
+    EffectEvidenceSynthesisUnitOfMeasure["Fmol/mg{protein}"] = "fmol/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/L/mmol{creat}"] = "nmol/L/mmol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["[Btu]"] = "[Btu]";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/{RBC}"] = "pmol/{RBC}";
+    EffectEvidenceSynthesisUnitOfMeasure["/10*3.{RBCs}"] = "/10*3.{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/mmol{creat}"] = "g/mmol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["{AntibodyResponse'U}"] = "{AntibodyResponse'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/kg"] = "[IU]/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["U/kg{hemoglobin}"] = "U/kg{hemoglobin}";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/mg"] = "mU/mg";
+    EffectEvidenceSynthesisUnitOfMeasure["Cm[H2O]"] = "cm[H2O]";
+    EffectEvidenceSynthesisUnitOfMeasure["AU"] = "AU";
+    EffectEvidenceSynthesisUnitOfMeasure["Pg/{RBC}"] = "pg/{RBC}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{reactive}"] = "%{reactive}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/g{globulin}"] = "g/g{globulin}";
+    EffectEvidenceSynthesisUnitOfMeasure["{cells}"] = "{cells}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Live}"] = "%{Live}";
+    EffectEvidenceSynthesisUnitOfMeasure["[pwt_tr]"] = "[pwt_tr]";
+    EffectEvidenceSynthesisUnitOfMeasure["[ligne]"] = "[ligne]";
+    EffectEvidenceSynthesisUnitOfMeasure["{IFA_index}"] = "{IFA_index}";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/mL/min"] = "mU/mL/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*"] = "10*";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/min/mg{prot}"] = "pmol/min/mg{prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["[G]"] = "[G]";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/(24.h)"] = "mL/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[ka'U]"] = "[ka'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["G/L"] = "g/L";
+    EffectEvidenceSynthesisUnitOfMeasure["/100"] = "/100";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/mL{rbc}"] = "ng/mL{rbc}";
+    EffectEvidenceSynthesisUnitOfMeasure["st"] = "st";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/mol"] = "umol/mol";
+    EffectEvidenceSynthesisUnitOfMeasure["Kat/L"] = "kat/L";
+    EffectEvidenceSynthesisUnitOfMeasure["U/g{hemoglobin}"] = "U/g{hemoglobin}";
+    EffectEvidenceSynthesisUnitOfMeasure["KU/L{class}"] = "kU/L{class}";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/mg{prot}"] = "pmol/mg{prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/h/mg{protein}"] = "nmol/h/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*3{copies}/mL"] = "10*3{copies}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/h"] = "mmol/h";
+    EffectEvidenceSynthesisUnitOfMeasure["[ppth]"] = "[ppth]";
+    EffectEvidenceSynthesisUnitOfMeasure["{genomes}/mL"] = "{genomes}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol"] = "mmol";
+    EffectEvidenceSynthesisUnitOfMeasure["Gon"] = "gon";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/dL/h"] = "ng/dL/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/mmol"] = "mg/mmol";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/mmol{Cre}"] = "mg/mmol{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["/100{neutrophils}"] = "/100{neutrophils}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/(18.h)"] = "mmol/(18.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/min"] = "mmol/min";
+    EffectEvidenceSynthesisUnitOfMeasure["{spermatozoa}/mL"] = "{spermatozoa}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/mg{Cre}"] = "mg/mg{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/kg/h"] = "ng/kg/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/(kg.h)"] = "ug/(kg.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{ToxoplasmaIndexValue}"] = "{ToxoplasmaIndexValue}";
+    EffectEvidenceSynthesisUnitOfMeasure["/[IU]"] = "/[IU]";
+    EffectEvidenceSynthesisUnitOfMeasure["/d"] = "/d";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/(10.h)"] = "mg/(10.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[cin_i]"] = "[cin_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["[oz_av]"] = "[oz_av]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/10*6"] = "ng/10*6";
+    EffectEvidenceSynthesisUnitOfMeasure["%{HemoglobinA1C}"] = "%{HemoglobinA1C}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Ehrlich'U}/mL"] = "{Ehrlich'U}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["{Applicator}"] = "{Applicator}";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol"] = "pmol";
+    EffectEvidenceSynthesisUnitOfMeasure["M[IU]/mL"] = "m[IU]/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/g{creat}"] = "mg/g{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["U/mL"] = "U/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["[scwt_av]"] = "[scwt_av]";
+    EffectEvidenceSynthesisUnitOfMeasure["[cicero]"] = "[cicero]";
+    EffectEvidenceSynthesisUnitOfMeasure["s"] = "s";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/(5.h)"] = "mmol/(5.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/h/mg{protein}"] = "pmol/h/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["{ElisaU}/mL"] = "{ElisaU}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*12/L"] = "10*12/L";
+    EffectEvidenceSynthesisUnitOfMeasure["G%"] = "g%";
+    EffectEvidenceSynthesisUnitOfMeasure["Mol/mL"] = "mol/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/dL"] = "meq/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["Lx"] = "lx";
+    EffectEvidenceSynthesisUnitOfMeasure["{Bottle}"] = "{Bottle}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol{ATP}"] = "nmol{ATP}";
+    EffectEvidenceSynthesisUnitOfMeasure["Lm"] = "lm";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/mL/h"] = "ng/mL/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/g{Tissue}"] = "ug/g{Tissue}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/dL{GF}"] = "umol/dL{GF}";
+    EffectEvidenceSynthesisUnitOfMeasure["/kg{body'wt}"] = "/kg{body'wt}";
+    EffectEvidenceSynthesisUnitOfMeasure["{rbc}"] = "{rbc}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug{T4}/dL"] = "ug{T4}/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/mmol"] = "umol/mmol";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*3/uL"] = "10*3/uL";
+    EffectEvidenceSynthesisUnitOfMeasure["{Log_copies}/mL"] = "{Log_copies}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Fmol/mg"] = "fmol/mg";
+    EffectEvidenceSynthesisUnitOfMeasure["Lm/m2"] = "lm/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["%{blockade}"] = "%{blockade}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/mL{class}"] = "ug/mL{class}";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/min"] = "mU/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Gy"] = "Gy";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*3"] = "10*3";
+    EffectEvidenceSynthesisUnitOfMeasure["/[HPF]"] = "/[HPF]";
+    EffectEvidenceSynthesisUnitOfMeasure["{M.o.M}"] = "{M.o.M}";
+    EffectEvidenceSynthesisUnitOfMeasure["Pg/mL"] = "pg/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["{JDF'U}"] = "{JDF'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["A_t"] = "a_t";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/g{Hgb}"] = "ug/g{Hgb}";
+    EffectEvidenceSynthesisUnitOfMeasure["[sin_i]"] = "[sin_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/h/mL"] = "pmol/h/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["U{25Cel}/L"] = "U{25Cel}/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10^"] = "10^";
+    EffectEvidenceSynthesisUnitOfMeasure["{WBCs}"] = "{WBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["{4 times}/d"] = "{4 times}/d";
+    EffectEvidenceSynthesisUnitOfMeasure["Ci"] = "Ci";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/g{tissue}"] = "mg/g{tissue}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/ng"] = "ug/ng";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/L{37Cel}"] = "[IU]/L{37Cel}";
+    EffectEvidenceSynthesisUnitOfMeasure["Pa"] = "Pa";
+    EffectEvidenceSynthesisUnitOfMeasure["{ERY}/uL"] = "{ERY}/uL";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/umol{creat}"] = "pmol/umol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["{binding_index}"] = "{binding_index}";
+    EffectEvidenceSynthesisUnitOfMeasure["MeV"] = "MeV";
+    EffectEvidenceSynthesisUnitOfMeasure["B[kW]"] = "B[kW]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/kg/d"] = "mg/kg/d";
+    EffectEvidenceSynthesisUnitOfMeasure["/ug"] = "/ug";
+    EffectEvidenceSynthesisUnitOfMeasure["GBq"] = "GBq";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/(kg.d)"] = "ug/(kg.d)";
+    EffectEvidenceSynthesisUnitOfMeasure["[tsp_us]"] = "[tsp_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/g{dry_tissue}"] = "mg/g{dry_tissue}";
+    EffectEvidenceSynthesisUnitOfMeasure["/10*3"] = "/10*3";
+    EffectEvidenceSynthesisUnitOfMeasure["UOhm"] = "uOhm";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/(8.h)"] = "mL/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["/100{spermatozoa}"] = "/100{spermatozoa}";
+    EffectEvidenceSynthesisUnitOfMeasure["Fmol/mL"] = "fmol/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["{# of fetuses}"] = "{# of fetuses}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/mL{eqv}"] = "ug/mL{eqv}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Packs}/d"] = "{Packs}/d";
+    EffectEvidenceSynthesisUnitOfMeasure["[S]"] = "[S]";
+    EffectEvidenceSynthesisUnitOfMeasure["G/min"] = "g/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mol"] = "nmol/mol";
+    EffectEvidenceSynthesisUnitOfMeasure["MU"] = "mU";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug"] = "ug";
+    EffectEvidenceSynthesisUnitOfMeasure["Ml"] = "ml";
+    EffectEvidenceSynthesisUnitOfMeasure["%[slope]"] = "%[slope]";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/mg{creat}"] = "mU/mg{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["G.m/{beat}"] = "g.m/{beat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Num1/d"] = "1/d";
+    EffectEvidenceSynthesisUnitOfMeasure["B[mV]"] = "B[mV]";
+    EffectEvidenceSynthesisUnitOfMeasure["MBq"] = "MBq";
+    EffectEvidenceSynthesisUnitOfMeasure["UU"] = "uU";
+    EffectEvidenceSynthesisUnitOfMeasure["[PRU]"] = "[PRU]";
+    EffectEvidenceSynthesisUnitOfMeasure["{Cells}/mL"] = "{Cells}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["L/(min.m2)"] = "L/(min.m2)";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/L"] = "ug/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Kg/m2"] = "kg/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["[smoot]"] = "[smoot]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/dL"] = "ug/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["[p'diop]"] = "[p'diop]";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mg{prot}"] = "nmol/mg{prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["[ppm]"] = "[ppm]";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Total}"] = "%{Total}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(24.h)"] = "g/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*Num3{Polarization'U}"] = "10*-3{Polarization'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["Pm"] = "pm";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/h/mg{protein}"] = "umol/h/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["G{total_prot}"] = "g{total_prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["/10*9"] = "/10*9";
+    EffectEvidenceSynthesisUnitOfMeasure["/g{wet_tis}"] = "/g{wet_tis}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{inhibition}"] = "%{inhibition}";
+    EffectEvidenceSynthesisUnitOfMeasure["/100{cells}"] = "/100{cells}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/min/mg{prot}"] = "nmol/min/mg{prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["B[SPL]"] = "B[SPL]";
+    EffectEvidenceSynthesisUnitOfMeasure["{Events}"] = "{Events}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/kg"] = "ng/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["[gal_br]"] = "[gal_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["/a"] = "/a";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/m/mg{prot}"] = "nmol/m/mg{prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["{#}/[LPF]"] = "{#}/[LPF]";
+    EffectEvidenceSynthesisUnitOfMeasure["G/{total_weight}"] = "g/{total_weight}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mg{protein}"] = "nmol/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["[fdr_us]"] = "[fdr_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/mg"] = "ug/mg";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/{specimen}"] = "ug/{specimen}";
+    EffectEvidenceSynthesisUnitOfMeasure["U/(24.h)"] = "U/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/mmol"] = "mmol/mmol";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/kg/h"] = "mmol/kg/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug{FEU}/mL"] = "ug{FEU}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["ML"] = "mL";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/[sin_i]"] = "mL/[sin_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6/(24.h)"] = "10*6/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["U/min"] = "U/min";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/d"] = "mL/d";
+    EffectEvidenceSynthesisUnitOfMeasure["[APL'U]/mL"] = "[APL'U]/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["''"] = "''";
+    EffectEvidenceSynthesisUnitOfMeasure["%{0to3Hours}"] = "%{0to3Hours}";
+    EffectEvidenceSynthesisUnitOfMeasure["[lbf_av]"] = "[lbf_av]";
+    EffectEvidenceSynthesisUnitOfMeasure["H/wk"] = "h/wk";
+    EffectEvidenceSynthesisUnitOfMeasure["/10*12{RBCs}"] = "/10*12{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["/h"] = "/h";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Hemolysis}"] = "%{Hemolysis}";
+    EffectEvidenceSynthesisUnitOfMeasure["/kg"] = "/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["U/g{Hb}"] = "U/g{Hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["[MPL'U]"] = "[MPL'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/mol{creat}"] = "mmol/mol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/g{wet_tissue}"] = "mg/g{wet_tissue}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/L{RBCs}"] = "umol/L{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["Rad"] = "rad";
+    EffectEvidenceSynthesisUnitOfMeasure["Ueq"] = "ueq";
+    EffectEvidenceSynthesisUnitOfMeasure["Ohm.m"] = "Ohm.m";
+    EffectEvidenceSynthesisUnitOfMeasure["{OpticalDensityIndex}"] = "{OpticalDensityIndex}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/(kg.h)"] = "ng/(kg.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/kg/min"] = "mmol/kg/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10.L/(min.m2)"] = "10.L/(min.m2)";
+    EffectEvidenceSynthesisUnitOfMeasure["%{BasalActivity}"] = "%{BasalActivity}";
+    EffectEvidenceSynthesisUnitOfMeasure["[APL'U]"] = "[APL'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["[Btu_39]"] = "[Btu_39]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/mg"] = "ng/mg";
+    EffectEvidenceSynthesisUnitOfMeasure["B[W]"] = "B[W]";
+    EffectEvidenceSynthesisUnitOfMeasure["DL"] = "dL";
+    EffectEvidenceSynthesisUnitOfMeasure["{CGG_repeats}"] = "{CGG_repeats}";
+    EffectEvidenceSynthesisUnitOfMeasure["U/kg{Hb}"] = "U/kg{Hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/(kg.h)"] = "mg/(kg.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*9/mL"] = "10*9/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Nm"] = "nm";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/L"] = "ng/L";
+    EffectEvidenceSynthesisUnitOfMeasure["{mutation}"] = "{mutation}";
+    EffectEvidenceSynthesisUnitOfMeasure["EV"] = "eV";
+    EffectEvidenceSynthesisUnitOfMeasure["[drp]/[HPF]"] = "[drp]/[HPF]";
+    EffectEvidenceSynthesisUnitOfMeasure["%{response}"] = "%{response}";
+    EffectEvidenceSynthesisUnitOfMeasure["/min"] = "/min";
+    EffectEvidenceSynthesisUnitOfMeasure["/[LPF]"] = "/[LPF]";
+    EffectEvidenceSynthesisUnitOfMeasure["[pca]"] = "[pca]";
+    EffectEvidenceSynthesisUnitOfMeasure["[pk_us]"] = "[pk_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["{ComplementCH50'U}"] = "{ComplementCH50'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6.[IU]"] = "10*6.[IU]";
+    EffectEvidenceSynthesisUnitOfMeasure["M/s2"] = "m/s2";
+    EffectEvidenceSynthesisUnitOfMeasure["{cells}/uL"] = "{cells}/uL";
+    EffectEvidenceSynthesisUnitOfMeasure["%{WBCs}"] = "%{WBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/g"] = "meq/g";
+    EffectEvidenceSynthesisUnitOfMeasure["{3 times}/d"] = "{3 times}/d";
+    EffectEvidenceSynthesisUnitOfMeasure["{GPortionPhospholipids}"] = "{G-PortionPhospholipids}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol"] = "umol";
+    EffectEvidenceSynthesisUnitOfMeasure["Fmol/L"] = "fmol/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/mol{creat}"] = "umol/mol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Volume}/{Vvolume}"] = "{Volume}/{Vvolume}";
+    EffectEvidenceSynthesisUnitOfMeasure["Wb"] = "Wb";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/min/mg{Hb}"] = "nmol/min/mg{Hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["{ARU}"] = "{ARU}";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/{beat}"] = "mL/{beat}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Dose}"] = "{Dose}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ukat"] = "ukat";
+    EffectEvidenceSynthesisUnitOfMeasure["Mm3"] = "mm3";
+    EffectEvidenceSynthesisUnitOfMeasure["{Dalton}"] = "{Dalton}";
+    EffectEvidenceSynthesisUnitOfMeasure["L"] = "L";
+    EffectEvidenceSynthesisUnitOfMeasure["U/g{Cre}"] = "U/g{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["{#}"] = "{#}";
+    EffectEvidenceSynthesisUnitOfMeasure["mv"] = "mV";
+    EffectEvidenceSynthesisUnitOfMeasure["%{binding}"] = "%{binding}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mg{prot}/h"] = "nmol/mg{prot}/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg"] = "mg";
+    EffectEvidenceSynthesisUnitOfMeasure["%{pooled_plasma}"] = "%{pooled_plasma}";
+    EffectEvidenceSynthesisUnitOfMeasure["{OpticalDensity}"] = "{OpticalDensity}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/{TotalVolume}"] = "ug/{TotalVolume}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{NormalControl}"] = "%{NormalControl}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Log}"] = "{Log}";
+    EffectEvidenceSynthesisUnitOfMeasure["[m_p]"] = "[m_p]";
+    EffectEvidenceSynthesisUnitOfMeasure["%/100{WBC}"] = "%/100{WBC}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/{Specimen}"] = "mg/{Specimen}";
+    EffectEvidenceSynthesisUnitOfMeasure["Kcal/kg/(24.h)"] = "kcal/kg/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/mg{Cre}"] = "ug/mg{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["[LPF]"] = "[LPF]";
+    EffectEvidenceSynthesisUnitOfMeasure["M2"] = "m2";
+    EffectEvidenceSynthesisUnitOfMeasure["Num1"] = "1";
+    EffectEvidenceSynthesisUnitOfMeasure["Bit"] = "bit";
+    EffectEvidenceSynthesisUnitOfMeasure["{CPM}"] = "{CPM}";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6/L"] = "10*6/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/g{DryWeight}"] = "ug/g{DryWeight}";
+    EffectEvidenceSynthesisUnitOfMeasure["[hp_M]"] = "[hp_M]";
+    EffectEvidenceSynthesisUnitOfMeasure["/10*6"] = "/10*6";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng{FEU}/mL"] = "ng{FEU}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["{Package}"] = "{Package}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ueq/mL"] = "ueq/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/mmol{creat}"] = "mg/mmol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/g{creat}"] = "umol/g{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mol/m3"] = "mol/m3";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/g{Hgb}"] = "mU/g{Hgb}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mmol{creat}"] = "nmol/mmol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{loss_AChR}"] = "%{loss_AChR}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/min/L"] = "umol/min/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Mol/L"] = "mol/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Ky"] = "Ky";
+    EffectEvidenceSynthesisUnitOfMeasure["{Molecule}/{Platelet}"] = "{Molecule}/{Platelet}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/dL"] = "mmol/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*3/L"] = "10*3/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Pg/mg{creat}"] = "pg/mg{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/L"] = "meq/L";
+    EffectEvidenceSynthesisUnitOfMeasure["%{hemolysis}"] = "%{hemolysis}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(8.h){shift}"] = "g/(8.h){shift}";
+    EffectEvidenceSynthesisUnitOfMeasure["[lk_br]"] = "[lk_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["L/s"] = "L/s";
+    EffectEvidenceSynthesisUnitOfMeasure["L/min"] = "L/min";
+    EffectEvidenceSynthesisUnitOfMeasure["U/g{creat}"] = "U/g{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mx"] = "Mx";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Negative Control}"] = "%{Negative Control}";
+    EffectEvidenceSynthesisUnitOfMeasure["NU/{RBC}"] = "nU/{RBC}";
+    EffectEvidenceSynthesisUnitOfMeasure["Erg"] = "erg";
+    EffectEvidenceSynthesisUnitOfMeasure["L/h"] = "L/h";
+    EffectEvidenceSynthesisUnitOfMeasure["%{TotalProtein}"] = "%{TotalProtein}";
+    EffectEvidenceSynthesisUnitOfMeasure["K[IU]/L"] = "k[IU]/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/{Tot'Volume}"] = "mg/{Tot'Volume}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{abnormal}"] = "%{abnormal}";
+    EffectEvidenceSynthesisUnitOfMeasure["[in_i'H2O]"] = "[in_i'H2O]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ms"] = "Ms";
+    EffectEvidenceSynthesisUnitOfMeasure["{Tscore}"] = "{Tscore}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/mol{Cre}"] = "mmol/mol{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["KU/h"] = "kU/h";
+    EffectEvidenceSynthesisUnitOfMeasure["A/m"] = "A/m";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/g{Cre}"] = "ug/g{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["[dr_ap]"] = "[dr_ap]";
+    EffectEvidenceSynthesisUnitOfMeasure["{HaTiter}"] = "{HaTiter}";
+    EffectEvidenceSynthesisUnitOfMeasure["Kat"] = "kat";
+    EffectEvidenceSynthesisUnitOfMeasure["{copies}/mL"] = "{copies}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/min"] = "mL/min";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/(12.h)"] = "mL/(12.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[hnsf'U]"] = "[hnsf'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6/{Specimen}"] = "10*6/{Specimen}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/mg{protein}"] = "ng/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["/[iU]"] = "/[iU]";
+    EffectEvidenceSynthesisUnitOfMeasure["Hz"] = "Hz";
+    EffectEvidenceSynthesisUnitOfMeasure["{FIU}"] = "{FIU}";
+    EffectEvidenceSynthesisUnitOfMeasure["[yd_br]"] = "[yd_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["{FluorescenceIntensity'U}"] = "{FluorescenceIntensity'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Rubella_virus}"] = "{Rubella_virus}";
+    EffectEvidenceSynthesisUnitOfMeasure["{P2Y12 Reaction Units}"] = "{P2Y12 Reaction Units}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Hemoglobin}"] = "%{Hemoglobin}";
+    EffectEvidenceSynthesisUnitOfMeasure["[drp]/mL"] = "[drp]/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["[cyd_i]"] = "[cyd_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["[fur_us]"] = "[fur_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["FL"] = "fL";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/(4.h)"] = "mL/(4.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{# of donor informative markers}"] = "{# of donor informative markers}";
+    EffectEvidenceSynthesisUnitOfMeasure["KV"] = "kV";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/m3"] = "mg/m3";
+    EffectEvidenceSynthesisUnitOfMeasure["[pt_us]"] = "[pt_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ueq/L"] = "ueq/L";
+    EffectEvidenceSynthesisUnitOfMeasure["%{ofAvailable}"] = "%{ofAvailable}";
+    EffectEvidenceSynthesisUnitOfMeasure["{phenotype}"] = "{phenotype}";
+    EffectEvidenceSynthesisUnitOfMeasure["[pc_br]"] = "[pc_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["G/mL"] = "g/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["[D'ag'U]"] = "[D'ag'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["G"] = "G";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/kg/(8.h)"] = "mg/kg/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[HPF]"] = "[HPF]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ps"] = "ps";
+    EffectEvidenceSynthesisUnitOfMeasure["L/s/s2"] = "L/s/s2";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6.eq/mL"] = "10*6.eq/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["KBq"] = "kBq";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/d/{1.73_m2}"] = "mg/d/{1.73_m2}";
+    EffectEvidenceSynthesisUnitOfMeasure["[AU]"] = "[AU]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ao"] = "Ao";
+    EffectEvidenceSynthesisUnitOfMeasure["[drp]/h"] = "[drp]/h";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/(8.h)/kg"] = "mL/(8.h)/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/mg{creat}"] = "mg/mg{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/L/(24.h)"] = "ug/L/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/mm"] = "mL/mm";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/L{RBCs}"] = "nmol/L{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["[car_Au]"] = "[car_Au]";
+    EffectEvidenceSynthesisUnitOfMeasure["Dg"] = "dg";
+    EffectEvidenceSynthesisUnitOfMeasure["Sr"] = "sr";
+    EffectEvidenceSynthesisUnitOfMeasure["%{normal}"] = "%{normal}";
+    EffectEvidenceSynthesisUnitOfMeasure["/{oif}"] = "/{oif}";
+    EffectEvidenceSynthesisUnitOfMeasure["{ElisaValue}"] = "{ElisaValue}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol{BCE}/mmol{creat}"] = "nmol{BCE}/mmol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/d"] = "mg/d";
+    EffectEvidenceSynthesisUnitOfMeasure["[Btu_th]"] = "[Btu_th]";
+    EffectEvidenceSynthesisUnitOfMeasure["[iU]/mL"] = "[iU]/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["{IndexValue}"] = "{IndexValue}";
+    EffectEvidenceSynthesisUnitOfMeasure["[GPL'U]/mL"] = "[GPL'U]/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["{Ct}"] = "{Ct}";
+    EffectEvidenceSynthesisUnitOfMeasure["{IFA_titer}"] = "{IFA_titer}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/{total_output}"] = "mg/{total_output}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{lysis}"] = "%{lysis}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/mg"] = "mg/mg";
+    EffectEvidenceSynthesisUnitOfMeasure["{JuvenileDiabetesFound'U}"] = "{JuvenileDiabetesFound'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Each}"] = "{Each}";
+    EffectEvidenceSynthesisUnitOfMeasure["[fth_br]"] = "[fth_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/mmol{RBCs}"] = "mU/mmol{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["{log_IU}/mL"] = "{log_IU}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/g{Cre}"] = "nmol/g{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Copies}/mL"] = "{Copies}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Cal_[15]"] = "cal_[15]";
+    EffectEvidenceSynthesisUnitOfMeasure["DB"] = "dB";
+    EffectEvidenceSynthesisUnitOfMeasure["[lb_tr]"] = "[lb_tr]";
+    EffectEvidenceSynthesisUnitOfMeasure["L/d"] = "L/d";
+    EffectEvidenceSynthesisUnitOfMeasure["[Btu_m]"] = "[Btu_m]";
+    EffectEvidenceSynthesisUnitOfMeasure["J"] = "J";
+    EffectEvidenceSynthesisUnitOfMeasure["MPa.s"] = "mPa.s";
+    EffectEvidenceSynthesisUnitOfMeasure["[iU]"] = "[iU]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/kg{H2O}"] = "mmol/kg{H2O}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mbar/L/s"] = "mbar/L/s";
+    EffectEvidenceSynthesisUnitOfMeasure["{RubellaVirus}"] = "{RubellaVirus}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/m/mg{protein}"] = "nmol/m/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["Pg/{cell}"] = "pg/{cell}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/wk"] = "mg/wk";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/g{hemoglobin}"] = "mmol/g{hemoglobin}";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/(2.h)"] = "[IU]/(2.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{EIATiter}"] = "{EIATiter}";
+    EffectEvidenceSynthesisUnitOfMeasure["{ISR}"] = "{ISR}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/mL{RBCs}"] = "ng/mL{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(48.h)"] = "g/(48.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["G/mg"] = "g/mg";
+    EffectEvidenceSynthesisUnitOfMeasure["FL/nL"] = "fL/nL";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/g"] = "nmol/g";
+    EffectEvidenceSynthesisUnitOfMeasure["[mu_0]"] = "[mu_0]";
+    EffectEvidenceSynthesisUnitOfMeasure["/(12.h)"] = "/(12.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[pi].rad/min"] = "[pi].rad/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/kg"] = "ug/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/min"] = "pmol/min";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/min"] = "[IU]/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Ks"] = "ks";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/m"] = "mmol/m";
+    EffectEvidenceSynthesisUnitOfMeasure["Ns"] = "ns";
+    EffectEvidenceSynthesisUnitOfMeasure["Kg{wet'tis}"] = "kg{wet'tis}";
+    EffectEvidenceSynthesisUnitOfMeasure["Kg/h"] = "kg/h";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Blockade}"] = "%{Blockade}";
+    EffectEvidenceSynthesisUnitOfMeasure["{minidrop}/s"] = "{minidrop}/s";
+    EffectEvidenceSynthesisUnitOfMeasure["G/kg/d"] = "g/kg/d";
+    EffectEvidenceSynthesisUnitOfMeasure["{KRONU'U}/mL"] = "{KRONU'U}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/{TotalVolume}"] = "mmol/{TotalVolume}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mo"] = "mo";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/(6.h)"] = "mmol/(6.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{CAG_repeats}"] = "{CAG_repeats}";
+    EffectEvidenceSynthesisUnitOfMeasure["J/L"] = "J/L";
+    EffectEvidenceSynthesisUnitOfMeasure["{IgAAntiphosphatidyleserine'U}"] = "{IgAAntiphosphatidyleserine'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["[BAU]"] = "[BAU]";
+    EffectEvidenceSynthesisUnitOfMeasure["M"] = "m";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/(12.h)"] = "meq/(12.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Gal"] = "Gal";
+    EffectEvidenceSynthesisUnitOfMeasure["[fdr_br]"] = "[fdr_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["{CPM}/10*3{cell}"] = "{CPM}/10*3{cell}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mg{creat}"] = "nmol/mg{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/h"] = "ug/h";
+    EffectEvidenceSynthesisUnitOfMeasure["{GAA_repeats}"] = "{GAA_repeats}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/g{tissue}"] = "ug/g{tissue}";
+    EffectEvidenceSynthesisUnitOfMeasure["[lk_us]"] = "[lk_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10.uN.s/(cm5.m2)"] = "10.uN.s/(cm5.m2)";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/{Specimen}"] = "ug/{Specimen}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/kg/d"] = "mmol/kg/d";
+    EffectEvidenceSynthesisUnitOfMeasure["{Bead}"] = "{Bead}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/{total_output}"] = "g/{total_output}";
+    EffectEvidenceSynthesisUnitOfMeasure["KU/g"] = "kU/g";
+    EffectEvidenceSynthesisUnitOfMeasure["PT"] = "pT";
+    EffectEvidenceSynthesisUnitOfMeasure["/{tot}"] = "/{tot}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/min/10*6{cells}"] = "nmol/min/10*6{cells}";
+    EffectEvidenceSynthesisUnitOfMeasure["Kg/(s.m2)"] = "kg/(s.m2)";
+    EffectEvidenceSynthesisUnitOfMeasure["{cfu}"] = "{cfu}";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/(kg.min)"] = "mL/(kg.min)";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/{h'b}"] = "mL/{h'b}";
+    EffectEvidenceSynthesisUnitOfMeasure["[pi]"] = "[pi]";
+    EffectEvidenceSynthesisUnitOfMeasure["Oe"] = "Oe";
+    EffectEvidenceSynthesisUnitOfMeasure["UL/(2.h)"] = "uL/(2.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["UU/g"] = "uU/g";
+    EffectEvidenceSynthesisUnitOfMeasure["St"] = "St";
+    EffectEvidenceSynthesisUnitOfMeasure["/g{wet'tis}"] = "/g{wet'tis}";
+    EffectEvidenceSynthesisUnitOfMeasure["{risk}"] = "{risk}";
+    EffectEvidenceSynthesisUnitOfMeasure["{INR}"] = "{INR}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/mL"] = "mg/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/(6.h)"] = "mL/(6.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{count}"] = "{count}";
+    EffectEvidenceSynthesisUnitOfMeasure["[acr_us]"] = "[acr_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/mg{prot}"] = "ng/mg{prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6/uL"] = "10*6/uL";
+    EffectEvidenceSynthesisUnitOfMeasure["{#}/d"] = "{#}/d";
+    EffectEvidenceSynthesisUnitOfMeasure["{LymeIndexValue}"] = "{LymeIndexValue}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mho"] = "mho";
+    EffectEvidenceSynthesisUnitOfMeasure["{index}"] = "{index}";
+    EffectEvidenceSynthesisUnitOfMeasure["U/g{protein}"] = "U/g{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["{#}/wk"] = "{#}/wk";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/m"] = "umol/m";
+    EffectEvidenceSynthesisUnitOfMeasure["Sv"] = "Sv";
+    EffectEvidenceSynthesisUnitOfMeasure["[lb_av]"] = "[lb_av]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mol/mol{creat}"] = "mol/mol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["[lcwt_av]"] = "[lcwt_av]";
+    EffectEvidenceSynthesisUnitOfMeasure["/g{tot_prot}"] = "/g{tot_prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/kg/d"] = "ug/kg/d";
+    EffectEvidenceSynthesisUnitOfMeasure["{KRONU'U}/L"] = "{KRONU'U}/L";
+    EffectEvidenceSynthesisUnitOfMeasure["[iU]/dL"] = "[iU]/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["S"] = "S";
+    EffectEvidenceSynthesisUnitOfMeasure["{IgGAntiphosphatidyleserine'U}"] = "{IgGAntiphosphatidyleserine'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/g{hair}"] = "ug/g{hair}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{baseline}"] = "%{baseline}";
+    EffectEvidenceSynthesisUnitOfMeasure["{EIA'U}/U"] = "{EIA'U}/U";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/g{Cre}"] = "umol/g{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["L.s2/s"] = "L.s2/s";
+    EffectEvidenceSynthesisUnitOfMeasure["[kn_i]"] = "[kn_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["G{creat}"] = "g{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["[Btu_IT]"] = "[Btu_IT]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg{creat}"] = "mg{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/min"] = "ng/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/mmol{creat}"] = "ug/mmol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["[min_br]"] = "[min_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["%{SpermMotility}"] = "%{SpermMotility}";
+    EffectEvidenceSynthesisUnitOfMeasure["[in_i]"] = "[in_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["{Log_IU}/mL"] = "{Log_IU}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["{Ehrlich'U}/100.g"] = "{Ehrlich'U}/100.g";
+    EffectEvidenceSynthesisUnitOfMeasure["[drp]"] = "[drp]";
+    EffectEvidenceSynthesisUnitOfMeasure["{Vial}"] = "{Vial}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/dL"] = "mg/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["Cm[H2O]/L/s"] = "cm[H2O]/L/s";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/umol{creat}"] = "nmol/umol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["{INR'unit}"] = "{INR'unit}";
+    EffectEvidenceSynthesisUnitOfMeasure["[car_m]"] = "[car_m]";
+    EffectEvidenceSynthesisUnitOfMeasure["/g{Hb}"] = "/g{Hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["{#}/min"] = "{#}/min";
+    EffectEvidenceSynthesisUnitOfMeasure["U/umol"] = "U/umol";
+    EffectEvidenceSynthesisUnitOfMeasure["{IgGIndex}"] = "{IgGIndex}";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/(5.h)"] = "mL/(5.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{Pill}"] = "{Pill}";
+    EffectEvidenceSynthesisUnitOfMeasure["[CFU]"] = "[CFU]";
+    EffectEvidenceSynthesisUnitOfMeasure["{Cans}/wk"] = "{Cans}/wk";
+    EffectEvidenceSynthesisUnitOfMeasure["[nmi_br]"] = "[nmi_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["Lm.m2"] = "lm.m2";
+    EffectEvidenceSynthesisUnitOfMeasure["[nmi_i]"] = "[nmi_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["H"] = "H";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(8.h)"] = "g/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["/m3"] = "/m3";
+    EffectEvidenceSynthesisUnitOfMeasure["M2/s"] = "m2/s";
+    EffectEvidenceSynthesisUnitOfMeasure["Deg"] = "deg";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/(6.h)"] = "mg/(6.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[gal_us]"] = "[gal_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Cm[Hg]"] = "cm[Hg]";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/(2.h)"] = "mL/(2.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["/{Specimen}"] = "/{Specimen}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mg{protein}/h"] = "nmol/mg{protein}/h";
+    EffectEvidenceSynthesisUnitOfMeasure["{CfTiter}"] = "{CfTiter}";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/{total_volume}"] = "meq/{total_volume}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mosm"] = "mosm";
+    EffectEvidenceSynthesisUnitOfMeasure["[PNU]"] = "[PNU]";
+    EffectEvidenceSynthesisUnitOfMeasure["Km"] = "km";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10.uN.s/cm2"] = "10.uN.s/cm2";
+    EffectEvidenceSynthesisUnitOfMeasure["[rd_br]"] = "[rd_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["%{OfWBCs}"] = "%{OfWBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Positive}"] = "%{Positive}";
+    EffectEvidenceSynthesisUnitOfMeasure["{RecTiter}"] = "{RecTiter}";
+    EffectEvidenceSynthesisUnitOfMeasure["/10*12{rbc}"] = "/10*12{rbc}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/mg{creat}"] = "ug/mg{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/mbar"] = "mL/mbar";
+    EffectEvidenceSynthesisUnitOfMeasure["U/10"] = "U/10";
+    EffectEvidenceSynthesisUnitOfMeasure["M[iU]"] = "m[iU]";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/kg"] = "umol/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["H/d"] = "h/d";
+    EffectEvidenceSynthesisUnitOfMeasure["{Can}"] = "{Can}";
+    EffectEvidenceSynthesisUnitOfMeasure["Cm2/s"] = "cm2/s";
+    EffectEvidenceSynthesisUnitOfMeasure["Dyn.s/cm"] = "dyn.s/cm";
+    EffectEvidenceSynthesisUnitOfMeasure["{Ehrlich'U}/(2.h)"] = "{Ehrlich'U}/(2.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Min/wk"] = "min/wk";
+    EffectEvidenceSynthesisUnitOfMeasure["G/kg/(8.h)"] = "g/kg/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["/mg"] = "/mg";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/s"] = "mL/s";
+    EffectEvidenceSynthesisUnitOfMeasure["%{saturation}"] = "%{saturation}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ph"] = "ph";
+    EffectEvidenceSynthesisUnitOfMeasure["L/kg"] = "L/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["KU"] = "kU";
+    EffectEvidenceSynthesisUnitOfMeasure["{delta_OD}"] = "{delta_OD}";
+    EffectEvidenceSynthesisUnitOfMeasure["Um"] = "um";
+    EffectEvidenceSynthesisUnitOfMeasure["Um/s"] = "um/s";
+    EffectEvidenceSynthesisUnitOfMeasure["[drp]/min"] = "[drp]/min";
+    EffectEvidenceSynthesisUnitOfMeasure["PA"] = "pA";
+    EffectEvidenceSynthesisUnitOfMeasure["[iU]/L"] = "[iU]/L";
+    EffectEvidenceSynthesisUnitOfMeasure["[syd_i]"] = "[syd_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/mg"] = "umol/mg";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Uptake}"] = "%{Uptake}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/g"] = "ug/g";
+    EffectEvidenceSynthesisUnitOfMeasure["{5 times}/d"] = "{5 times}/d";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/g{Hb}"] = "mU/g{Hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/h"] = "mg/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10.L/min"] = "10.L/min";
+    EffectEvidenceSynthesisUnitOfMeasure["[tbs_us]"] = "[tbs_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["/mm3"] = "/mm3";
+    EffectEvidenceSynthesisUnitOfMeasure["A_g"] = "a_g";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/g{Hgb}"] = "umol/g{Hgb}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/g{tissue}"] = "g/g{tissue}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{total}"] = "%{total}";
+    EffectEvidenceSynthesisUnitOfMeasure["{score}"] = "{score}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/mmol"] = "g/mmol";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/L"] = "[IU]/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Eq/L"] = "eq/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/(8.h.kg)"] = "meq/(8.h.kg)";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/mL"] = "pmol/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/kg/min"] = "mL/kg/min";
+    EffectEvidenceSynthesisUnitOfMeasure["M/s"] = "m/s";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/mmol{creat}"] = "pmol/mmol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mo_s"] = "mo_s";
+    EffectEvidenceSynthesisUnitOfMeasure["%"] = "%";
+    EffectEvidenceSynthesisUnitOfMeasure["Sph"] = "sph";
+    EffectEvidenceSynthesisUnitOfMeasure["G.m/{H.B.}"] = "g.m/{H.B.}";
+    EffectEvidenceSynthesisUnitOfMeasure["Kcal"] = "kcal";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/m2"] = "mg/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["{TSI_index}"] = "{TSI_index}";
+    EffectEvidenceSynthesisUnitOfMeasure["[cup_us]"] = "[cup_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["N.cm"] = "N.cm";
+    EffectEvidenceSynthesisUnitOfMeasure["U/10*12"] = "U/10*12";
+    EffectEvidenceSynthesisUnitOfMeasure["{dilution}"] = "{dilution}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/mL"] = "ug/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Mol/kg/s"] = "mol/kg/s";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/{total_volume}"] = "mg/{total_volume}";
+    EffectEvidenceSynthesisUnitOfMeasure["[Ch]"] = "[Ch]";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/{beat}/m2"] = "mL/{beat}/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]"] = "[IU]";
+    EffectEvidenceSynthesisUnitOfMeasure["{Beats}/min"] = "{Beats}/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/h"] = "umol/h";
+    EffectEvidenceSynthesisUnitOfMeasure["{Times}/wk"] = "{Times}/wk";
+    EffectEvidenceSynthesisUnitOfMeasure["Mm[H2O]"] = "mm[H2O]";
+    EffectEvidenceSynthesisUnitOfMeasure["Fmol/mg{cytosol_protein}"] = "fmol/mg{cytosol_protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{bound}"] = "%{bound}";
+    EffectEvidenceSynthesisUnitOfMeasure["[yd_i]"] = "[yd_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/kg/min"] = "mg/kg/min";
+    EffectEvidenceSynthesisUnitOfMeasure["R"] = "R";
+    EffectEvidenceSynthesisUnitOfMeasure["{Scoop}"] = "{Scoop}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/g{dry_wt}"] = "ug/g{dry_wt}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Tine'U}"] = "{Tine'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Elisa_U}/mL"] = "{Elisa_U}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["UCi"] = "uCi";
+    EffectEvidenceSynthesisUnitOfMeasure["U/mL{RBC}"] = "U/mL{RBC}";
+    EffectEvidenceSynthesisUnitOfMeasure["[ft_us]"] = "[ft_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["[bu_br]"] = "[bu_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["[in_i'Hg]"] = "[in_i'Hg]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/{Hgb}/g"] = "mg/{Hgb}/g";
+    EffectEvidenceSynthesisUnitOfMeasure["[dqt_us]"] = "[dqt_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["C"] = "C";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg{FEU}/L"] = "mg{FEU}/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*3.{RBC}"] = "10*3.{RBC}";
+    EffectEvidenceSynthesisUnitOfMeasure["B[uV]"] = "B[uV]";
+    EffectEvidenceSynthesisUnitOfMeasure["[m_e]"] = "[m_e]";
+    EffectEvidenceSynthesisUnitOfMeasure["{#}/a"] = "{#}/a";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/h/mg{prot}"] = "mmol/h/mg{prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["ms"] = "ms";
+    EffectEvidenceSynthesisUnitOfMeasure["{breaths}/min"] = "{breaths}/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Eq/umol"] = "eq/umol";
+    EffectEvidenceSynthesisUnitOfMeasure["Wk"] = "wk";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/{Specimen}"] = "meq/{Specimen}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/{total_vol}"] = "mmol/{total_vol}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{viable}"] = "%{viable}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/min"] = "umol/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Num24.h"] = "24.h";
+    EffectEvidenceSynthesisUnitOfMeasure["[dpt_us]"] = "[dpt_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/mol"] = "mmol/mol";
+    EffectEvidenceSynthesisUnitOfMeasure["{GPS'U}"] = "{GPS'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/m2"] = "meq/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["U/(1.h)"] = "U/(1.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["/L"] = "/L";
+    EffectEvidenceSynthesisUnitOfMeasure["/[arb'U]"] = "/[arb'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["[eps_0]"] = "[eps_0]";
+    EffectEvidenceSynthesisUnitOfMeasure["U[IU]/mL"] = "u[IU]/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Kcal/[oz_av]"] = "kcal/[oz_av]";
+    EffectEvidenceSynthesisUnitOfMeasure["F"] = "F";
+    EffectEvidenceSynthesisUnitOfMeasure["[ft_us]/[ft_us]"] = "[ft_us]/[ft_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["/dL"] = "/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["{STDV}"] = "{STDV}";
+    EffectEvidenceSynthesisUnitOfMeasure["{ELISA'U}"] = "{ELISA'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["Cal_th"] = "cal_th";
+    EffectEvidenceSynthesisUnitOfMeasure["G/d"] = "g/d";
+    EffectEvidenceSynthesisUnitOfMeasure["U/10*9"] = "U/10*9";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/mg{Cre}"] = "mU/mg{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["Circ"] = "circ";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/h/mg{prot}"] = "nmol/h/mg{prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["[ft_br]"] = "[ft_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["M[H2O]"] = "m[H2O]";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Binding}"] = "%{Binding}";
+    EffectEvidenceSynthesisUnitOfMeasure["/{Entity}"] = "/{Entity}";
+    EffectEvidenceSynthesisUnitOfMeasure["{HA_titer}"] = "{HA_titer}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(72.h)"] = "g/(72.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/mg{creat}"] = "[IU]/mg{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["L/(8.h)"] = "L/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["/uL"] = "/uL";
+    EffectEvidenceSynthesisUnitOfMeasure["UL/h"] = "uL/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Pkat"] = "pkat";
+    EffectEvidenceSynthesisUnitOfMeasure["{percentile}"] = "{percentile}";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/(24.h)"] = "pmol/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/d"] = "umol/d";
+    EffectEvidenceSynthesisUnitOfMeasure["Mo_g"] = "mo_g";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/L"] = "pmol/L";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/min/(173.10*Num2.m2)"] = "mL/min/(173.10*-2.m2)";
+    EffectEvidenceSynthesisUnitOfMeasure["[mil_us]"] = "[mil_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["{index_val}"] = "{index_val}";
+    EffectEvidenceSynthesisUnitOfMeasure["{JDF'U}/L"] = "{JDF'U}/L";
+    EffectEvidenceSynthesisUnitOfMeasure["UU/L"] = "uU/L";
+    EffectEvidenceSynthesisUnitOfMeasure["[srd_us]"] = "[srd_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/kg/h"] = "mg/kg/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6/kg"] = "10*6/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/{Tot'Volume}"] = "mmol/{Tot'Volume}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/h/L"] = "nmol/h/L";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/g"] = "[IU]/g";
+    EffectEvidenceSynthesisUnitOfMeasure["{Number}"] = "{Number}";
+    EffectEvidenceSynthesisUnitOfMeasure["Kcal/(8.h)"] = "kcal/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["MV/s"] = "mV/s";
+    EffectEvidenceSynthesisUnitOfMeasure["%{residual}"] = "%{residual}";
+    EffectEvidenceSynthesisUnitOfMeasure["Osm/kg"] = "osm/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["{KCT'U}"] = "{KCT'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["{ComplementCH100'U}"] = "{ComplementCH100'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["{minidrp}"] = "{minidrp}";
+    EffectEvidenceSynthesisUnitOfMeasure["/10*10"] = "/10*10";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/min/mL"] = "nmol/min/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/U"] = "ng/U";
+    EffectEvidenceSynthesisUnitOfMeasure["B"] = "B";
+    EffectEvidenceSynthesisUnitOfMeasure["{IgMAntiphosphatidyleserine'U}"] = "{IgMAntiphosphatidyleserine'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{HumanResponse}"] = "%{HumanResponse}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/{TotalWeight}"] = "g/{TotalWeight}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{recovery}"] = "%{recovery}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/s"] = "nmol/s";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/mmol{creatinine}"] = "mU/mmol{creatinine}";
+    EffectEvidenceSynthesisUnitOfMeasure["/g{HGB}"] = "/g{HGB}";
+    EffectEvidenceSynthesisUnitOfMeasure["U/10*10{cells}"] = "U/10*10{cells}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Streptozyme'U}"] = "{Streptozyme'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{penetration}"] = "%{penetration}";
+    EffectEvidenceSynthesisUnitOfMeasure["/cm[H2O]"] = "/cm[H2O]";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/d"] = "nmol/d";
+    EffectEvidenceSynthesisUnitOfMeasure["{IfaIndex}"] = "{IfaIndex}";
+    EffectEvidenceSynthesisUnitOfMeasure["G{total_nit}"] = "g{total_nit}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Cells}/uL"] = "{Cells}/uL";
+    EffectEvidenceSynthesisUnitOfMeasure["a"] = "a";
+    EffectEvidenceSynthesisUnitOfMeasure["U/dL"] = "U/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["G/kg/(8.h){shift}"] = "g/kg/(8.h){shift}";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/kg/d"] = "[IU]/kg/d";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/g{feces}"] = "ug/g{feces}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Count}"] = "{Count}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/s/L"] = "mmol/s/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*8"] = "10*8";
+    EffectEvidenceSynthesisUnitOfMeasure["{Pan_Bio'U}"] = "{Pan_Bio'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["[didot]"] = "[didot]";
+    EffectEvidenceSynthesisUnitOfMeasure["[bu_us]"] = "[bu_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ag/{cell}"] = "ag/{cell}";
+    EffectEvidenceSynthesisUnitOfMeasure["Cal"] = "cal";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Abnormal}"] = "%{Abnormal}";
+    EffectEvidenceSynthesisUnitOfMeasure["[qt_us]"] = "[qt_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/dL"] = "mL/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["{#}/g"] = "{#}/g";
+    EffectEvidenceSynthesisUnitOfMeasure["[diop]"] = "[diop]";
+    EffectEvidenceSynthesisUnitOfMeasure["[PFU]"] = "[PFU]";
+    EffectEvidenceSynthesisUnitOfMeasure["{copies}/ug"] = "{copies}/ug";
+    EffectEvidenceSynthesisUnitOfMeasure["Kg/L"] = "kg/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Torr"] = "Torr";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/mL{FEU}"] = "ug/mL{FEU}";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/d"] = "[IU]/d";
+    EffectEvidenceSynthesisUnitOfMeasure["[dye'U]"] = "[dye'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["Eq/mL"] = "eq/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/dL"] = "pmol/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["Bd"] = "Bd";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/g"] = "mU/g";
+    EffectEvidenceSynthesisUnitOfMeasure["[hd_i]"] = "[hd_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["{mm/dd/yyyy}"] = "{mm/dd/yyyy}";
+    EffectEvidenceSynthesisUnitOfMeasure["[pk_br]"] = "[pk_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["{# of informative markers}"] = "{# of informative markers}";
+    EffectEvidenceSynthesisUnitOfMeasure["Fg"] = "fg";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/kg/(8.h)"] = "ug/kg/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["MA"] = "mA";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/mg{Cre}"] = "umol/mg{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol{1/2cys}/mg{protein}"] = "nmol{1/2cys}/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["/10*12"] = "/10*12";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/g{protein}"] = "mU/g{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/dL{RBCs}"] = "mg/dL{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["[twp]"] = "[twp]";
+    EffectEvidenceSynthesisUnitOfMeasure["[TCID_50]"] = "[TCID_50]";
+    EffectEvidenceSynthesisUnitOfMeasure["[lb_ap]"] = "[lb_ap]";
+    EffectEvidenceSynthesisUnitOfMeasure["{2 or 3 times}/d"] = "{2 or 3 times}/d";
+    EffectEvidenceSynthesisUnitOfMeasure["Osm"] = "osm";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(3.d)"] = "g/(3.d)";
+    EffectEvidenceSynthesisUnitOfMeasure["/100{WBCs}"] = "/100{WBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/umol{creat}"] = "umol/umol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Cm2"] = "cm2";
+    EffectEvidenceSynthesisUnitOfMeasure["U/mmol{creat}"] = "U/mmol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(100.g)"] = "g/(100.g)";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/(2.h)"] = "umol/(2.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["G/kg/min"] = "g/kg/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Nm/s/L"] = "nm/s/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/h"] = "ng/h";
+    EffectEvidenceSynthesisUnitOfMeasure["G/g{creat}"] = "g/g{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["{EIA'U}"] = "{EIA'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Markers}"] = "{Markers}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Drinks}/d"] = "{Drinks}/d";
+    EffectEvidenceSynthesisUnitOfMeasure["{Log_IU}"] = "{Log_IU}";
+    EffectEvidenceSynthesisUnitOfMeasure["{CH100'U}"] = "{CH100'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/({h'b}.m2)"] = "mL/({h'b}.m2)";
+    EffectEvidenceSynthesisUnitOfMeasure["[iU]/g"] = "[iU]/g";
+    EffectEvidenceSynthesisUnitOfMeasure["L/(24.h)"] = "L/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["G/cm2"] = "g/cm2";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/g{dry_tissue}"] = "ug/g{dry_tissue}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mg"] = "nmol/mg";
+    EffectEvidenceSynthesisUnitOfMeasure["[drp]/s"] = "[drp]/s";
+    EffectEvidenceSynthesisUnitOfMeasure["%{OfLymphocytes}"] = "%{OfLymphocytes}";
+    EffectEvidenceSynthesisUnitOfMeasure["{copies}"] = "{copies}";
+    EffectEvidenceSynthesisUnitOfMeasure["U/kg/h"] = "U/kg/h";
+    EffectEvidenceSynthesisUnitOfMeasure["UL"] = "uL";
+    EffectEvidenceSynthesisUnitOfMeasure["[mi_br]"] = "[mi_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["{clock_time}"] = "{clock_time}";
+    EffectEvidenceSynthesisUnitOfMeasure["'"] = "'";
+    EffectEvidenceSynthesisUnitOfMeasure["/m2"] = "/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Carboxyhemoglobin}"] = "%{Carboxyhemoglobin}";
+    EffectEvidenceSynthesisUnitOfMeasure["[hp_Q]"] = "[hp_Q]";
+    EffectEvidenceSynthesisUnitOfMeasure["[c]"] = "[c]";
+    EffectEvidenceSynthesisUnitOfMeasure["G.m/({hb}.m2)"] = "g.m/({hb}.m2)";
+    EffectEvidenceSynthesisUnitOfMeasure["[mi_us]"] = "[mi_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["{RadioactiveT3UptakeRatio}"] = "{RadioactiveT3UptakeRatio}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/g{Hb}"] = "umol/g{Hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["P"] = "P";
+    EffectEvidenceSynthesisUnitOfMeasure["CP"] = "cP";
+    EffectEvidenceSynthesisUnitOfMeasure["[CCID_50]"] = "[CCID_50]";
+    EffectEvidenceSynthesisUnitOfMeasure["{IfaTiter}"] = "{IfaTiter}";
+    EffectEvidenceSynthesisUnitOfMeasure["[Amb'a'1'U]"] = "[Amb'a'1'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg{Phenylketones}/dL"] = "mg{Phenylketones}/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["[gil_us]"] = "[gil_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["{ImmuneStatusRatio}"] = "{ImmuneStatusRatio}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/L{rbc}"] = "umol/L{rbc}";
+    EffectEvidenceSynthesisUnitOfMeasure["[ly]"] = "[ly]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/(12.h)"] = "mmol/(12.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/mL"] = "meq/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["[MPL'U]/mL"] = "[MPL'U]/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/d"] = "mmol/d";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/{specimen}"] = "meq/{specimen}";
+    EffectEvidenceSynthesisUnitOfMeasure["[oz_tr]"] = "[oz_tr]";
+    EffectEvidenceSynthesisUnitOfMeasure["UV"] = "uV";
+    EffectEvidenceSynthesisUnitOfMeasure["[k]"] = "[k]";
+    EffectEvidenceSynthesisUnitOfMeasure["Pg/mL{sLT}"] = "pg/mL{sLT}";
+    EffectEvidenceSynthesisUnitOfMeasure["{DdTiter}"] = "{DdTiter}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Index}"] = "%{Index}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/min/mg{protein}"] = "nmol/min/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["{TmStp}"] = "{TmStp}";
+    EffectEvidenceSynthesisUnitOfMeasure["DaL/min/m2"] = "daL/min/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["/g{creat}"] = "/g{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["[rlk_us]"] = "[rlk_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/(100.g)"] = "ug/(100.g)";
+    EffectEvidenceSynthesisUnitOfMeasure["KL"] = "kL";
+    EffectEvidenceSynthesisUnitOfMeasure["{log_copies}/mL"] = "{log_copies}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6.[iU]"] = "10*6.[iU]";
+    EffectEvidenceSynthesisUnitOfMeasure["t"] = "t";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/{collection}"] = "mg/{collection}";
+    EffectEvidenceSynthesisUnitOfMeasure["Eq"] = "eq";
+    EffectEvidenceSynthesisUnitOfMeasure["U/s"] = "U/s";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(5.h)"] = "g/(5.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Us"] = "us";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/L/s"] = "mmol/L/s";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/{Volume}"] = "mg/{Volume}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/(8.h.kg)"] = "mmol/(8.h.kg)";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*3{RBCs}"] = "10*3{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["M[Hg]"] = "m[Hg]";
+    EffectEvidenceSynthesisUnitOfMeasure["NU/mL"] = "nU/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["[rch_us]"] = "[rch_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Kcal/d"] = "kcal/d";
+    EffectEvidenceSynthesisUnitOfMeasure["%{HemoglobinSaturation}"] = "%{HemoglobinSaturation}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Elisa'U}/mL"] = "{Elisa'U}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["/wk"] = "/wk";
+    EffectEvidenceSynthesisUnitOfMeasure["Cm/s"] = "cm/s";
+    EffectEvidenceSynthesisUnitOfMeasure["[pnt_pr]"] = "[pnt_pr]";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(4.h)"] = "g/(4.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{RBC}/uL"] = "{RBC}/uL";
+    EffectEvidenceSynthesisUnitOfMeasure["[CFU]/mL"] = "[CFU]/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["V"] = "V";
+    EffectEvidenceSynthesisUnitOfMeasure["U"] = "U";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/mmol{creat}"] = "mU/mmol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/{specimen}"] = "mg/{specimen}";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10.uN.s/cm"] = "10.uN.s/cm";
+    EffectEvidenceSynthesisUnitOfMeasure["{ThyroxinUptake'U}"] = "{ThyroxinUptake'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ohm"] = "Ohm";
+    EffectEvidenceSynthesisUnitOfMeasure["Eq/mmol"] = "eq/mmol";
+    EffectEvidenceSynthesisUnitOfMeasure["[bbl_us]"] = "[bbl_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["D/wk"] = "d/wk";
+    EffectEvidenceSynthesisUnitOfMeasure["G/g"] = "g/g";
+    EffectEvidenceSynthesisUnitOfMeasure["{NonspecificOunce}"] = "{NonspecificOunce}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/g{hemoglobin}"] = "umol/g{hemoglobin}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mL/h"] = "nmol/mL/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/10*6{RBC}"] = "umol/10*6{RBC}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Cound}"] = "%{Cound}";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq"] = "meq";
+    EffectEvidenceSynthesisUnitOfMeasure["ML{fetal_RBCs}"] = "mL{fetal_RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["[ch_us]"] = "[ch_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["{OpticalDensityRatio}"] = "{OpticalDensityRatio}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/cm3"] = "g/cm3";
+    EffectEvidenceSynthesisUnitOfMeasure["{beats}/min"] = "{beats}/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Bi"] = "Bi";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/dL"] = "[IU]/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["G/h/m2"] = "g/h/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/g"] = "umol/g";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/kg"] = "mmol/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["Cm3"] = "cm3";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/L"] = "mL/L";
+    EffectEvidenceSynthesisUnitOfMeasure["[mclg'U]"] = "[mclg'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/L{RBCs}"] = "ug/L{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["Cd"] = "cd";
+    EffectEvidenceSynthesisUnitOfMeasure["{Ehrlich'U}/d"] = "{Ehrlich'U}/d";
+    EffectEvidenceSynthesisUnitOfMeasure["[in_br]"] = "[in_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["{AHF'U}"] = "{AHF'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["[lton_av]"] = "[lton_av]";
+    EffectEvidenceSynthesisUnitOfMeasure["[bf_i]"] = "[bf_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["/10*4{RBCs}"] = "/10*4{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/(18.h)"] = "mg/(18.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Min/d"] = "min/d";
+    EffectEvidenceSynthesisUnitOfMeasure["[iU]/kg"] = "[iU]/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["{PackYears}"] = "{PackYears}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/mol{Cre}"] = "umol/mol{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/d/(173.10*Num2.m2)"] = "mg/d/(173.10*-2.m2)";
+    EffectEvidenceSynthesisUnitOfMeasure["[tb'U]"] = "[tb'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["Dm2/s2"] = "dm2/s2";
+    EffectEvidenceSynthesisUnitOfMeasure["U/10*10"] = "U/10*10";
+    EffectEvidenceSynthesisUnitOfMeasure["b"] = "b";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/(10.h)"] = "mL/(10.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/g"] = "mmol/g";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/m2"] = "ng/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/mg{creat}"] = "umol/mg{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["/{OIF}"] = "/{OIF}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/L/s"] = "nmol/L/s";
+    EffectEvidenceSynthesisUnitOfMeasure["[sft_i]"] = "[sft_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["/mL"] = "/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["%{ofBacteria}"] = "%{ofBacteria}";
+    EffectEvidenceSynthesisUnitOfMeasure["[min_us]"] = "[min_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6"] = "10*6";
+    EffectEvidenceSynthesisUnitOfMeasure["/mo"] = "/mo";
+    EffectEvidenceSynthesisUnitOfMeasure["Dyn.s/(cm.m2)"] = "dyn.s/(cm.m2)";
+    EffectEvidenceSynthesisUnitOfMeasure["/100{WBC}"] = "/100{WBC}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/[sft_i]"] = "ug/[sft_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["{CGG}"] = "{CGG}";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/g{Hb}"] = "[IU]/g{Hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*Num6{Immunofluorescence'U}"] = "10*-6{Immunofluorescence'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/10*6{RBCs}"] = "ng/10*6{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["[acr_br]"] = "[acr_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["Bit_s"] = "bit_s";
+    EffectEvidenceSynthesisUnitOfMeasure["MPa"] = "mPa";
+    EffectEvidenceSynthesisUnitOfMeasure["{StimulatingIndex}"] = "{StimulatingIndex}";
+    EffectEvidenceSynthesisUnitOfMeasure["[arb'U]/mL"] = "[arb'U]/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["[knk'U]"] = "[knk'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["Cel"] = "Cel";
+    EffectEvidenceSynthesisUnitOfMeasure["Pg/mm"] = "pg/mm";
+    EffectEvidenceSynthesisUnitOfMeasure["HL"] = "hL";
+    EffectEvidenceSynthesisUnitOfMeasure["UU/mL"] = "uU/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/(24.h)"] = "meq/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/(8.h)"] = "mg/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{Percentile}"] = "{Percentile}";
+    EffectEvidenceSynthesisUnitOfMeasure["{EhrlichU}/dL"] = "{EhrlichU}/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["%{positive}"] = "%{positive}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Absorbance'U}"] = "{Absorbance'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["[hp_C]"] = "[hp_C]";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(kg.min)"] = "g/(kg.min)";
+    EffectEvidenceSynthesisUnitOfMeasure["{Once}/d"] = "{Once}/d";
+    EffectEvidenceSynthesisUnitOfMeasure["{IgAPhospholipid'U}"] = "{IgAPhospholipid'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["{StandardIgM'U}"] = "{StandardIgM'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(8.kg.h)"] = "g/(8.kg.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/kg/min"] = "meq/kg/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/h/mg{Hb}"] = "mmol/h/mg{Hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["K/W"] = "K/W";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/(72.h)"] = "mg/(72.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[FFU]"] = "[FFU]";
+    EffectEvidenceSynthesisUnitOfMeasure["[arb'U]"] = "[arb'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mbar"] = "mbar";
+    EffectEvidenceSynthesisUnitOfMeasure["U/g{Hgb}"] = "U/g{Hgb}";
+    EffectEvidenceSynthesisUnitOfMeasure["{minidrop}/min"] = "{minidrop}/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/g{creat}"] = "meq/g{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["{#}/{platelet}"] = "{#}/{platelet}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Tot'Hgb}"] = "%{Tot'Hgb}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/mmol"] = "ug/mmol";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mg/h"] = "nmol/mg/h";
+    EffectEvidenceSynthesisUnitOfMeasure["[ft_i]"] = "[ft_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["g"] = "g";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/g{creat}"] = "mmol/g{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*4/uL"] = "10*4/uL";
+    EffectEvidenceSynthesisUnitOfMeasure["MCi"] = "mCi";
+    EffectEvidenceSynthesisUnitOfMeasure["[arb'U]/L"] = "[arb'U]/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Mm/min"] = "mm/min";
+    EffectEvidenceSynthesisUnitOfMeasure["{Capsule}"] = "{Capsule}";
+    EffectEvidenceSynthesisUnitOfMeasure["{StandardDeviation}"] = "{StandardDeviation}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Tot'Cholesterol}"] = "%{Tot'Cholesterol}";
+    EffectEvidenceSynthesisUnitOfMeasure["{ScoreOf}"] = "{ScoreOf}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{at_60_min}"] = "%{at_60_min}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/kg"] = "mg/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/umol"] = "umol/umol";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/d"] = "meq/d";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/h"] = "mL/h";
+    EffectEvidenceSynthesisUnitOfMeasure["MV"] = "MV";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6/mm3"] = "10*6/mm3";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/min"] = "mg/min";
+    EffectEvidenceSynthesisUnitOfMeasure["By"] = "By";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/min/mg{hemoglobin}"] = "nmol/min/mg{hemoglobin}";
+    EffectEvidenceSynthesisUnitOfMeasure["CL"] = "cL";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*3.U"] = "10*3.U";
+    EffectEvidenceSynthesisUnitOfMeasure["l"] = "l";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Oxygen}"] = "%{Oxygen}";
+    EffectEvidenceSynthesisUnitOfMeasure["U/g"] = "U/g";
+    EffectEvidenceSynthesisUnitOfMeasure["{IgMIndex}"] = "{IgMIndex}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/nmol"] = "nmol/nmol";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/kg/(8.h)"] = "mL/kg/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[smgy'U]"] = "[smgy'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["U[IU]"] = "u[IU]";
+    EffectEvidenceSynthesisUnitOfMeasure["[gr]"] = "[gr]";
+    EffectEvidenceSynthesisUnitOfMeasure["G/mol{creat}"] = "g/mol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["N"] = "N";
+    EffectEvidenceSynthesisUnitOfMeasure["{StdDeviation'U}"] = "{StdDeviation'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["NL"] = "nL";
+    EffectEvidenceSynthesisUnitOfMeasure["Cm[H2O]/s/m"] = "cm[H2O]/s/m";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol{BCE}/L"] = "nmol{BCE}/L";
+    EffectEvidenceSynthesisUnitOfMeasure["/U"] = "/U";
+    EffectEvidenceSynthesisUnitOfMeasure["Mol/s"] = "mol/s";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mL/min"] = "nmol/mL/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Mm/h"] = "mm/h";
+    EffectEvidenceSynthesisUnitOfMeasure["{s_co_ratio}"] = "{s_co_ratio}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Fat}"] = "%{Fat}";
+    EffectEvidenceSynthesisUnitOfMeasure["{kp_C}"] = "{kp_C}";
+    EffectEvidenceSynthesisUnitOfMeasure["u"] = "u";
+    EffectEvidenceSynthesisUnitOfMeasure["{spray}"] = "{spray}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/L{RBCs}"] = "mmol/L{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["[crd_us]"] = "[crd_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Cal_[20]"] = "cal_[20]";
+    EffectEvidenceSynthesisUnitOfMeasure["{lgCopies}/ml"] = "{lgCopies}/ml";
+    EffectEvidenceSynthesisUnitOfMeasure["/g{tot'prot}"] = "/g{tot'prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["[GPL'U]"] = "[GPL'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/kg/h"] = "ug/kg/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/(2.h)"] = "mg/(2.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{fraction}"] = "{fraction}";
+    EffectEvidenceSynthesisUnitOfMeasure["/g{tot'nit}"] = "/g{tot'nit}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/h/mL"] = "nmol/h/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["{Ct_value}"] = "{Ct_value}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/L"] = "nmol/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Kcal/(24.h)"] = "kcal/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/min"] = "meq/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/dL"] = "umol/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/(24.h)"] = "[IU]/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[gal_wi]"] = "[gal_wi]";
+    EffectEvidenceSynthesisUnitOfMeasure["[iU]/g{Hgb}"] = "[iU]/g{Hgb}";
+    EffectEvidenceSynthesisUnitOfMeasure["Pg/L"] = "pg/L";
+    EffectEvidenceSynthesisUnitOfMeasure["{molecule}/{platelet}"] = "{molecule}/{platelet}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/min/g{protein}"] = "umol/min/g{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/(24.h)"] = "ug/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["%{deficient}"] = "%{deficient}";
+    EffectEvidenceSynthesisUnitOfMeasure["A"] = "A";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/kg/(8.h)"] = "mmol/kg/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[pt_br]"] = "[pt_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["{clock time}"] = "{clock time}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/g{Cre}"] = "ng/g{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["{OD_unit}"] = "{OD_unit}";
+    EffectEvidenceSynthesisUnitOfMeasure["{CagRepeat}"] = "{CagRepeat}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{NormalPooledPlasma}"] = "%{NormalPooledPlasma}";
+    EffectEvidenceSynthesisUnitOfMeasure["[Btu_59]"] = "[Btu_59]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mol/d"] = "mol/d";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/g"] = "mg/g";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/(24.h)"] = "mg/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol"] = "nmol";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mL"] = "nmol/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/(8.h)"] = "ng/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/g{creat}"] = "ug/g{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["{#}/[HPF]"] = "{#}/[HPF]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/g{Cre}"] = "mg/g{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{FetalErythrocytes}"] = "%{FetalErythrocytes}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/dL{GF}"] = "nmol/dL{GF}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Absorbance'U}/mL"] = "{Absorbance'U}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["{ratio}"] = "{ratio}";
+    EffectEvidenceSynthesisUnitOfMeasure["Kg.m/s"] = "kg.m/s";
+    EffectEvidenceSynthesisUnitOfMeasure["{EIAIndex}"] = "{EIAIndex}";
+    EffectEvidenceSynthesisUnitOfMeasure["/mm"] = "/mm";
+    EffectEvidenceSynthesisUnitOfMeasure["{tot}"] = "{tot}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/mL/min"] = "umol/mL/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/dL"] = "nmol/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/mg{protein}"] = "pmol/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{EosSeen}"] = "%{EosSeen}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/dL"] = "ng/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["G/mol"] = "g/mol";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/mg{creat}"] = "ng/mg{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["/g{hgb}"] = "/g{hgb}";
+    EffectEvidenceSynthesisUnitOfMeasure["Gb"] = "Gb";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/h/L"] = "umol/h/L";
+    EffectEvidenceSynthesisUnitOfMeasure["%{normal_pooled_plasma}"] = "%{normal_pooled_plasma}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/s/L"] = "nmol/s/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/kg/h"] = "meq/kg/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/g{Hb}"] = "ug/g{Hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["/g{tot_nit}"] = "/g{tot_nit}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/min/g"] = "umol/min/g";
+    EffectEvidenceSynthesisUnitOfMeasure["{EIA_titer}"] = "{EIA_titer}";
+    EffectEvidenceSynthesisUnitOfMeasure["[kn_br]"] = "[kn_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/d"] = "pmol/d";
+    EffectEvidenceSynthesisUnitOfMeasure["{tbl}"] = "{tbl}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Hb}"] = "%{Hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/L/h"] = "umol/L/h";
+    EffectEvidenceSynthesisUnitOfMeasure["%{loss}"] = "%{loss}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mol/kg"] = "mol/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["{Ehrlich_U}/dL"] = "{Ehrlich_U}/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["G{wet_tissue}"] = "g{wet_tissue}";
+    EffectEvidenceSynthesisUnitOfMeasure["[sct]"] = "[sct]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/(kg.d)"] = "ng/(kg.d)";
+    EffectEvidenceSynthesisUnitOfMeasure["{Counts}/min"] = "{Counts}/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/kg{feces}"] = "umol/kg{feces}";
+    EffectEvidenceSynthesisUnitOfMeasure["[psi]"] = "[psi]";
+    EffectEvidenceSynthesisUnitOfMeasure["U/10*12{RBCs}"] = "U/10*12{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["/mmol"] = "/mmol";
+    EffectEvidenceSynthesisUnitOfMeasure["{SatIndex}"] = "{SatIndex}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/(8.h)"] = "ug/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["G/kg/h"] = "g/kg/h";
+    EffectEvidenceSynthesisUnitOfMeasure["{saturation}"] = "{saturation}";
+    EffectEvidenceSynthesisUnitOfMeasure["{CAE'U}"] = "{CAE'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["[stone_av]"] = "[stone_av]";
+    EffectEvidenceSynthesisUnitOfMeasure["U/mL{RBCs}"] = "U/mL{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*9/L"] = "10*9/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Kcal/h"] = "kcal/h";
+    EffectEvidenceSynthesisUnitOfMeasure["RAD"] = "RAD";
+    EffectEvidenceSynthesisUnitOfMeasure["Mosm/L"] = "mosm/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/min/mg{protein}"] = "pmol/min/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6/mL"] = "10*6/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["M3/s"] = "m3/s";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/h"] = "meq/h";
+    EffectEvidenceSynthesisUnitOfMeasure["{M.o.M.}"] = "{M.o.M.}";
+    EffectEvidenceSynthesisUnitOfMeasure["[pnt]"] = "[pnt]";
+    EffectEvidenceSynthesisUnitOfMeasure["{MultOfMean}"] = "{MultOfMean}";
+    EffectEvidenceSynthesisUnitOfMeasure["Kat/kg"] = "kat/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Normal}"] = "%{Normal}";
+    EffectEvidenceSynthesisUnitOfMeasure["{RPI'U}"] = "{RPI'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["{APS'U}"] = "{APS'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/{specimen}"] = "mmol/{specimen}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mol{creat}"] = "nmol/mol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["h"] = "h";
+    EffectEvidenceSynthesisUnitOfMeasure["/mmol{creat}"] = "/mmol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["{StandardIgA'U}"] = "{StandardIgA'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["{RelativeViscosity}"] = "{RelativeViscosity}";
+    EffectEvidenceSynthesisUnitOfMeasure["Pg/mg"] = "pg/mg";
+    EffectEvidenceSynthesisUnitOfMeasure["U/(10.g){feces}"] = "U/(10.g){feces}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/(8.h.kg)"] = "ng/(8.h.kg)";
+    EffectEvidenceSynthesisUnitOfMeasure["Lmb"] = "Lmb";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/L"] = "mmol/L";
+    EffectEvidenceSynthesisUnitOfMeasure["[ppb]"] = "[ppb]";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/kg/h"] = "mL/kg/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/mol"] = "pmol/mol";
+    EffectEvidenceSynthesisUnitOfMeasure["[CFU]/L"] = "[CFU]/L";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/10*9{RBCs}"] = "[IU]/10*9{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/s"] = "ng/s";
+    EffectEvidenceSynthesisUnitOfMeasure["[h]"] = "[h]";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(12.h)"] = "g/(12.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{Copies}/uL"] = "{Copies}/uL";
+    EffectEvidenceSynthesisUnitOfMeasure["Fmol/mg{prot}"] = "fmol/mg{prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["[pptr]"] = "[pptr]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/dL{RBCs}"] = "ug/dL{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["Atm"] = "atm";
+    EffectEvidenceSynthesisUnitOfMeasure["{Cell}"] = "{Cell}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/{TotalVolume}"] = "mg/{TotalVolume}";
+    EffectEvidenceSynthesisUnitOfMeasure["NCi"] = "nCi";
+    EffectEvidenceSynthesisUnitOfMeasure["[bdsk'U]"] = "[bdsk'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/min"] = "ug/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Num1/min"] = "1/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/g"] = "ng/g";
+    EffectEvidenceSynthesisUnitOfMeasure["{Patch}"] = "{Patch}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Activity}"] = "%{Activity}";
+    EffectEvidenceSynthesisUnitOfMeasure["[foz_br]"] = "[foz_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["A_j"] = "a_j";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/g{creat}"] = "ng/g{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["{#}/L"] = "{#}/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/mL"] = "ng/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/m2"] = "mL/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["[pied]"] = "[pied]";
+    EffectEvidenceSynthesisUnitOfMeasure["{Immunity}"] = "{Immunity}";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6.[CFU]/L"] = "10*6.[CFU]/L";
+    EffectEvidenceSynthesisUnitOfMeasure["D/(7.d)"] = "d/(7.d)";
+    EffectEvidenceSynthesisUnitOfMeasure["{Relative'U}"] = "{Relative'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/m2"] = "mmol/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/mg{cre}"] = "mg/mg{cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["U/(2.h)"] = "U/(2.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/d"] = "ug/d";
+    EffectEvidenceSynthesisUnitOfMeasure["[ppm]{v/v}"] = "[ppm]{v/v}";
+    EffectEvidenceSynthesisUnitOfMeasure["REM"] = "REM";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mmol"] = "nmol/mmol";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol{BCE}"] = "nmol{BCE}";
+    EffectEvidenceSynthesisUnitOfMeasure["[gil_br]"] = "[gil_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["[Lf]"] = "[Lf]";
+    EffectEvidenceSynthesisUnitOfMeasure["{shift}"] = "{shift}";
+    EffectEvidenceSynthesisUnitOfMeasure["/10*3{RBCs}"] = "/10*3{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/min/{1.73_m2}"] = "mL/min/{1.73_m2}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ar"] = "ar";
+    EffectEvidenceSynthesisUnitOfMeasure["G/(6.h)"] = "g/(6.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{MPS'U}/mL"] = "{MPS'U}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["G/dL"] = "g/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["U/(12.h)"] = "U/(12.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Kg"] = "kg";
+    EffectEvidenceSynthesisUnitOfMeasure["%{blocked}"] = "%{blocked}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/(8.h)"] = "umol/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*9/uL"] = "10*9/uL";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/h/mg{protein}"] = "mmol/h/mg{protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{uptake}"] = "%{uptake}";
+    EffectEvidenceSynthesisUnitOfMeasure["[pca_pr]"] = "[pca_pr]";
+    EffectEvidenceSynthesisUnitOfMeasure["%{reference}"] = "%{reference}";
+    EffectEvidenceSynthesisUnitOfMeasure["Cg"] = "cg";
+    EffectEvidenceSynthesisUnitOfMeasure["{#}/mL"] = "{#}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["{absorbance}"] = "{absorbance}";
+    EffectEvidenceSynthesisUnitOfMeasure["[sc_ap]"] = "[sc_ap]";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/min/m2"] = "mL/min/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Precipitate}"] = "%{Precipitate}";
+    EffectEvidenceSynthesisUnitOfMeasure["Osm/L"] = "osm/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/min/g{prot}"] = "umol/min/g{prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/m3"] = "ug/m3";
+    EffectEvidenceSynthesisUnitOfMeasure["{Ehrlich'U}"] = "{Ehrlich'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["U/L"] = "U/L";
+    EffectEvidenceSynthesisUnitOfMeasure["/s"] = "/s";
+    EffectEvidenceSynthesisUnitOfMeasure["[e]"] = "[e]";
+    EffectEvidenceSynthesisUnitOfMeasure["[fth_i]"] = "[fth_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["{Globules}/[HPF]"] = "{Globules}/[HPF]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/(24.h)"] = "ng/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Pc"] = "pc";
+    EffectEvidenceSynthesisUnitOfMeasure["{InhaledTobaccoUseAmountYears}"] = "{InhaledTobaccoUseAmountYears}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/mmol{urea}"] = "mmol/mmol{urea}";
+    EffectEvidenceSynthesisUnitOfMeasure["Sb"] = "sb";
+    EffectEvidenceSynthesisUnitOfMeasure["%{index}"] = "%{index}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mm"] = "mm";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*6.U"] = "10*6.U";
+    EffectEvidenceSynthesisUnitOfMeasure["Pmol/mmol"] = "pmol/mmol";
+    EffectEvidenceSynthesisUnitOfMeasure["[ch_br]"] = "[ch_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["DaL/min"] = "daL/min";
+    EffectEvidenceSynthesisUnitOfMeasure["[MET]"] = "[MET]";
+    EffectEvidenceSynthesisUnitOfMeasure["{activity}"] = "{activity}";
+    EffectEvidenceSynthesisUnitOfMeasure["[cml_i]"] = "[cml_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/(8.h)"] = "mmol/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{Lyme_index_value}"] = "{Lyme_index_value}";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/{ejaculate}"] = "mmol/{ejaculate}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Dilution}"] = "{Dilution}";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/kg/d"] = "mL/kg/d";
+    EffectEvidenceSynthesisUnitOfMeasure["Bar"] = "bar";
+    EffectEvidenceSynthesisUnitOfMeasure["W"] = "W";
+    EffectEvidenceSynthesisUnitOfMeasure["G/{specimen}"] = "g/{specimen}";
+    EffectEvidenceSynthesisUnitOfMeasure["[qt_br]"] = "[qt_br]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/mg/h"] = "ng/mg/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Np"] = "Np";
+    EffectEvidenceSynthesisUnitOfMeasure["N.s"] = "N.s";
+    EffectEvidenceSynthesisUnitOfMeasure["[mi_i]"] = "[mi_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/L"] = "umol/L";
+    EffectEvidenceSynthesisUnitOfMeasure["U/(18.h)"] = "U/(18.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{cells}/[HPF]"] = "{cells}/[HPF]";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Excretion}"] = "%{Excretion}";
+    EffectEvidenceSynthesisUnitOfMeasure["[foz_us]"] = "[foz_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/g{creat}"] = "nmol/g{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["{StandardIgG'U}"] = "{StandardIgG'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["[Btu_60]"] = "[Btu_60]";
+    EffectEvidenceSynthesisUnitOfMeasure["{InhaledTobaccoUsePacks}/d"] = "{InhaledTobaccoUsePacks}/d";
+    EffectEvidenceSynthesisUnitOfMeasure["G/h"] = "g/h";
+    EffectEvidenceSynthesisUnitOfMeasure["Min"] = "min";
+    EffectEvidenceSynthesisUnitOfMeasure["Pg"] = "pg";
+    EffectEvidenceSynthesisUnitOfMeasure["{ElisaIndex}"] = "{ElisaIndex}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{basal_activity}"] = "%{basal_activity}";
+    EffectEvidenceSynthesisUnitOfMeasure["G{Hb}"] = "g{Hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Zscore}"] = "{Zscore}";
+    EffectEvidenceSynthesisUnitOfMeasure["Pg/dL"] = "pg/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["Cal_IT"] = "cal_IT";
+    EffectEvidenceSynthesisUnitOfMeasure["%{cells}"] = "%{cells}";
+    EffectEvidenceSynthesisUnitOfMeasure["G/m2"] = "g/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Conversion}"] = "%{Conversion}";
+    EffectEvidenceSynthesisUnitOfMeasure["[cft_i]"] = "[cft_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/(8.h)"] = "meq/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["%{aggregation}"] = "%{aggregation}";
+    EffectEvidenceSynthesisUnitOfMeasure["L/min/m2"] = "L/min/m2";
+    EffectEvidenceSynthesisUnitOfMeasure["%{relative}"] = "%{relative}";
+    EffectEvidenceSynthesisUnitOfMeasure["{Disintegrations}/min"] = "{Disintegrations}/min";
+    EffectEvidenceSynthesisUnitOfMeasure["[mil_i]"] = "[mil_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/L{DDU}"] = "ug/L{DDU}";
+    EffectEvidenceSynthesisUnitOfMeasure["{ImmuneComplex'U}"] = "{ImmuneComplex'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{Reactivity}"] = "%{Reactivity}";
+    EffectEvidenceSynthesisUnitOfMeasure["U{G}"] = "U{G}";
+    EffectEvidenceSynthesisUnitOfMeasure["[yd_us]"] = "[yd_us]";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/(24.h)"] = "umol/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/kg/min"] = "ng/kg/min";
+    EffectEvidenceSynthesisUnitOfMeasure["%{activity}"] = "%{activity}";
+    EffectEvidenceSynthesisUnitOfMeasure["[todd'U]"] = "[todd'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/mmol{creat}"] = "umol/mmol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["[HP]"] = "[HP]";
+    EffectEvidenceSynthesisUnitOfMeasure["{Bowls}/d"] = "{Bowls}/d";
+    EffectEvidenceSynthesisUnitOfMeasure["D"] = "d";
+    EffectEvidenceSynthesisUnitOfMeasure["Nkat"] = "nkat";
+    EffectEvidenceSynthesisUnitOfMeasure["[oz_ap]"] = "[oz_ap]";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/(2.h)"] = "meq/(2.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{#}/uL"] = "{#}/uL";
+    EffectEvidenceSynthesisUnitOfMeasure["K[iU]/mL"] = "k[iU]/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["[pouce]"] = "[pouce]";
+    EffectEvidenceSynthesisUnitOfMeasure["/kg{body_wt}"] = "/kg{body_wt}";
+    EffectEvidenceSynthesisUnitOfMeasure["[Cal]"] = "[Cal]";
+    EffectEvidenceSynthesisUnitOfMeasure["Meq/g{Cre}"] = "meq/g{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{risk}"] = "%{risk}";
+    EffectEvidenceSynthesisUnitOfMeasure["[degF]"] = "[degF]";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/kg"] = "mL/kg";
+    EffectEvidenceSynthesisUnitOfMeasure["U/h"] = "U/h";
+    EffectEvidenceSynthesisUnitOfMeasure["G.m"] = "g.m";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/g{prot}"] = "mU/g{prot}";
+    EffectEvidenceSynthesisUnitOfMeasure["M[IU]/L"] = "m[IU]/L";
+    EffectEvidenceSynthesisUnitOfMeasure["{# of calculi}"] = "{# of calculi}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{dose}"] = "%{dose}";
+    EffectEvidenceSynthesisUnitOfMeasure["{TIBC'U}"] = "{TIBC'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["{relative_saturation}"] = "{relative_saturation}";
+    EffectEvidenceSynthesisUnitOfMeasure["Kg/min"] = "kg/min";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/L"] = "mU/L";
+    EffectEvidenceSynthesisUnitOfMeasure["{Ehrlich'U}/dL"] = "{Ehrlich'U}/dL";
+    EffectEvidenceSynthesisUnitOfMeasure["[cr_i]"] = "[cr_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["[beth'U]"] = "[beth'U]";
+    EffectEvidenceSynthesisUnitOfMeasure["{yyyy}"] = "{yyyy}";
+    EffectEvidenceSynthesisUnitOfMeasure["[hp_X]"] = "[hp_X]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/(24.h)"] = "mmol/(24.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["{Spermatozoa}/mL"] = "{Spermatozoa}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Mbar.s/L"] = "mbar.s/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/mg{Protein}"] = "ng/mg{Protein}";
+    EffectEvidenceSynthesisUnitOfMeasure["/100{Spermatozoa}"] = "/100{Spermatozoa}";
+    EffectEvidenceSynthesisUnitOfMeasure["{EV}"] = "{EV}";
+    EffectEvidenceSynthesisUnitOfMeasure["MU/mL"] = "mU/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/(12.h)"] = "mg/(12.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[MET].min/wk"] = "[MET].min/wk";
+    EffectEvidenceSynthesisUnitOfMeasure["{AspirinReaction'U}"] = "{AspirinReaction'U}";
+    EffectEvidenceSynthesisUnitOfMeasure["Kg/mol"] = "kg/mol";
+    EffectEvidenceSynthesisUnitOfMeasure["{cfu}/mL"] = "{cfu}/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Kg/m3"] = "kg/m3";
+    EffectEvidenceSynthesisUnitOfMeasure["Mm2"] = "mm2";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/mol{Hb}"] = "umol/mol{Hb}";
+    EffectEvidenceSynthesisUnitOfMeasure["ML/cm[H2O]"] = "mL/cm[H2O]";
+    EffectEvidenceSynthesisUnitOfMeasure["{EIA_index}"] = "{EIA_index}";
+    EffectEvidenceSynthesisUnitOfMeasure["U/d"] = "U/d";
+    EffectEvidenceSynthesisUnitOfMeasure["Fm"] = "fm";
+    EffectEvidenceSynthesisUnitOfMeasure["Cal_m"] = "cal_m";
+    EffectEvidenceSynthesisUnitOfMeasure["KU/L"] = "kU/L";
+    EffectEvidenceSynthesisUnitOfMeasure["S/{control}"] = "s/{control}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol{BCE}/mol"] = "umol{BCE}/mol";
+    EffectEvidenceSynthesisUnitOfMeasure["{GliadinIndexValue}"] = "{GliadinIndexValue}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/(kg.min)"] = "ng/(kg.min)";
+    EffectEvidenceSynthesisUnitOfMeasure["{Index_val}"] = "{Index_val}";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/mL"] = "[IU]/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["Ug/kg/min"] = "ug/kg/min";
+    EffectEvidenceSynthesisUnitOfMeasure["Deg/s"] = "deg/s";
+    EffectEvidenceSynthesisUnitOfMeasure["U[IU]/L"] = "u[IU]/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Mmol/mmol{creat}"] = "mmol/mmol{creat}";
+    EffectEvidenceSynthesisUnitOfMeasure["Umol/min/g{mucosa}"] = "umol/min/g{mucosa}";
+    EffectEvidenceSynthesisUnitOfMeasure["{DeltaOpticalDensity}"] = "{DeltaOpticalDensity}";
+    EffectEvidenceSynthesisUnitOfMeasure["{WeeksDays}"] = "{WeeksDays}";
+    EffectEvidenceSynthesisUnitOfMeasure["[pH]"] = "[pH]";
+    EffectEvidenceSynthesisUnitOfMeasure["Dyn"] = "dyn";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng"] = "ng";
+    EffectEvidenceSynthesisUnitOfMeasure["%{RBCs}"] = "%{RBCs}";
+    EffectEvidenceSynthesisUnitOfMeasure["Ng/kg/(8.h)"] = "ng/kg/(8.h)";
+    EffectEvidenceSynthesisUnitOfMeasure["[IU]/h"] = "[IU]/h";
+    EffectEvidenceSynthesisUnitOfMeasure["[mesh_i]"] = "[mesh_i]";
+    EffectEvidenceSynthesisUnitOfMeasure["[lne]"] = "[lne]";
+    EffectEvidenceSynthesisUnitOfMeasure["Mg/g{feces}"] = "mg/g{feces}";
+    EffectEvidenceSynthesisUnitOfMeasure["[dr_av]"] = "[dr_av]";
+    EffectEvidenceSynthesisUnitOfMeasure["{ActivityCoefficient}"] = "{ActivityCoefficient}";
+    EffectEvidenceSynthesisUnitOfMeasure["Nmol/mmol{Cre}"] = "nmol/mmol{Cre}";
+    EffectEvidenceSynthesisUnitOfMeasure["%{excretion}"] = "%{excretion}";
+    EffectEvidenceSynthesisUnitOfMeasure["L/L"] = "L/L";
+    EffectEvidenceSynthesisUnitOfMeasure["Num10*3/mL"] = "10*3/mL";
+    EffectEvidenceSynthesisUnitOfMeasure["PL"] = "pL";
+})(EffectEvidenceSynthesisUnitOfMeasure = exports.EffectEvidenceSynthesisUnitOfMeasure || (exports.EffectEvidenceSynthesisUnitOfMeasure = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ElementDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ElementDefinition.d.ts
index d4a981d..8fcc261 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ElementDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ElementDefinition.d.ts
@@ -391,31 +391,16 @@ export interface ElementDefinitionConstraint extends Element {
     _expression?: Element;
     _human?: Element;
     /** error | warning */
-    severity: code;
+    severity: `${ElementDefinitionSeverity}`;
     _severity?: Element;
     _source?: Element;
     _xpath?: Element;
     _key?: Element;
 }
-/** Map element to another set of definitions */
-export interface ElementDefinitionMapping extends Element {
-    /** Reference to mapping declaration */
-    identity: id;
-    _identity?: Element;
-    /** Computable language of mapping */
-    language?: code;
-    _language?: Element;
-    /** Details of the mapping */
-    map: string;
-    _map?: Element;
-    /** Comments about the mapping or its use */
-    comment?: string;
-    _comment?: Element;
-}
 /** Element values that are used to distinguish the slices */
 export interface ElementDefinitionDiscriminator extends Element {
     /** value | exists | pattern | type | profile */
-    type: code;
+    type: `${ElementDefinitionType}`;
     _type?: Element;
     /** Path to element value */
     path: string;
@@ -432,31 +417,13 @@ export interface ElementDefinitionSlicing extends Element {
     ordered?: boolean;
     _ordered?: Element;
     /** closed | open | openAtEnd */
-    rules: code;
+    rules: `${ElementDefinitionRules}`;
     _rules?: Element;
 }
-/** Data type and Profile for this element */
-export interface ElementDefinitionType extends Element {
-    _code?: Element;
-    _aggregation?: Array<Element>;
-    _profile?: Array<Element>;
-    /** Data type or Resource (reference to definition) */
-    code: uri;
-    /** Profile (StructureDefinition or IG) on the Reference/canonical target - one must apply */
-    targetProfile?: Array<canonical>;
-    /** contained | referenced | bundled - how aggregated */
-    aggregation?: Array<code>;
-    /** either | independent | specific */
-    versioning?: code;
-    _targetProfile?: Array<Element>;
-    /** Profiles (StructureDefinition or IG) - one must apply */
-    profile?: Array<canonical>;
-    _versioning?: Element;
-}
 /** ValueSet details if this is coded */
 export interface ElementDefinitionBinding extends Element {
     /** required | extensible | preferred | example */
-    strength: code;
+    strength: `${ElementDefinitionStrength}`;
     _strength?: Element;
     /** Human explanation of the value set */
     description?: string;
@@ -465,6 +432,66 @@ export interface ElementDefinitionBinding extends Element {
     valueSet?: canonical;
     _valueSet?: Element;
 }
+/** Map element to another set of definitions */
+export interface ElementDefinitionMapping extends Element {
+    /** Reference to mapping declaration */
+    identity: id;
+    _identity?: Element;
+    /** Computable language of mapping */
+    language?: `${ElementDefinitionLanguage}`;
+    _language?: Element;
+    /** Details of the mapping */
+    map: string;
+    _map?: Element;
+    /** Comments about the mapping or its use */
+    comment?: string;
+    _comment?: Element;
+}
+/** value | exists | pattern | type | profile */
+export declare enum ElementDefinitionType {
+    Exists = "exists",
+    Pattern = "pattern",
+    Profile = "profile",
+    Type = "type",
+    Value = "value"
+}
+/** either | independent | specific */
+export declare enum ElementDefinitionVersioning {
+    Either = "either",
+    Independent = "independent",
+    Specific = "specific"
+}
+/** error | warning */
+export declare enum ElementDefinitionSeverity {
+    Error = "error",
+    Warning = "warning"
+}
+/** Base definition information for tools */
+export interface ElementDefinitionBase extends Element {
+    /** Path that identifies the base element */
+    path: string;
+    _path?: Element;
+    /** Min cardinality of the base element */
+    min: unsignedInt;
+    _min?: Element;
+    /** Max cardinality of the base element */
+    max: string;
+    _max?: Element;
+}
+/** Computable language of mapping */
+export declare enum ElementDefinitionLanguage {
+    "Application/hl7Cda+xml" = "application/hl7-cda+xml",
+    "Application/sparqlResults+xml" = "application/sparql-results+xml",
+    "Application/sql" = "application/sql",
+    "Application/xquery" = "application/xquery"
+}
+/** required | extensible | preferred | example */
+export declare enum ElementDefinitionStrength {
+    Example = "example",
+    Extensible = "extensible",
+    Preferred = "preferred",
+    Required = "required"
+}
 /** Example value (as defined for type) */
 export interface ElementDefinitionExample extends Element {
     valueBase64Binary: base64Binary;
@@ -540,15 +567,9 @@ export interface ElementDefinitionExample extends Element {
     valueUrl: url;
     _valueInteger: Element;
 }
-/** Base definition information for tools */
-export interface ElementDefinitionBase extends Element {
-    /** Path that identifies the base element */
-    path: string;
-    _path?: Element;
-    /** Min cardinality of the base element */
-    min: unsignedInt;
-    _min?: Element;
-    /** Max cardinality of the base element */
-    max: string;
-    _max?: Element;
+/** closed | open | openAtEnd */
+export declare enum ElementDefinitionRules {
+    Closed = "closed",
+    Open = "open",
+    OpenAtEnd = "openAtEnd"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ElementDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/ElementDefinition.js
index c8ad2e5..b2fe5ae 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ElementDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ElementDefinition.js
@@ -1,2 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementDefinitionRules = exports.ElementDefinitionStrength = exports.ElementDefinitionLanguage = exports.ElementDefinitionSeverity = exports.ElementDefinitionVersioning = exports.ElementDefinitionType = void 0;
+/** value | exists | pattern | type | profile */
+var ElementDefinitionType;
+(function (ElementDefinitionType) {
+    ElementDefinitionType["Exists"] = "exists";
+    ElementDefinitionType["Pattern"] = "pattern";
+    ElementDefinitionType["Profile"] = "profile";
+    ElementDefinitionType["Type"] = "type";
+    ElementDefinitionType["Value"] = "value";
+})(ElementDefinitionType = exports.ElementDefinitionType || (exports.ElementDefinitionType = {}));
+/** either | independent | specific */
+var ElementDefinitionVersioning;
+(function (ElementDefinitionVersioning) {
+    ElementDefinitionVersioning["Either"] = "either";
+    ElementDefinitionVersioning["Independent"] = "independent";
+    ElementDefinitionVersioning["Specific"] = "specific";
+})(ElementDefinitionVersioning = exports.ElementDefinitionVersioning || (exports.ElementDefinitionVersioning = {}));
+/** error | warning */
+var ElementDefinitionSeverity;
+(function (ElementDefinitionSeverity) {
+    ElementDefinitionSeverity["Error"] = "error";
+    ElementDefinitionSeverity["Warning"] = "warning";
+})(ElementDefinitionSeverity = exports.ElementDefinitionSeverity || (exports.ElementDefinitionSeverity = {}));
+/** Computable language of mapping */
+var ElementDefinitionLanguage;
+(function (ElementDefinitionLanguage) {
+    ElementDefinitionLanguage["Application/hl7Cda+xml"] = "application/hl7-cda+xml";
+    ElementDefinitionLanguage["Application/sparqlResults+xml"] = "application/sparql-results+xml";
+    ElementDefinitionLanguage["Application/sql"] = "application/sql";
+    ElementDefinitionLanguage["Application/xquery"] = "application/xquery";
+})(ElementDefinitionLanguage = exports.ElementDefinitionLanguage || (exports.ElementDefinitionLanguage = {}));
+/** required | extensible | preferred | example */
+var ElementDefinitionStrength;
+(function (ElementDefinitionStrength) {
+    ElementDefinitionStrength["Example"] = "example";
+    ElementDefinitionStrength["Extensible"] = "extensible";
+    ElementDefinitionStrength["Preferred"] = "preferred";
+    ElementDefinitionStrength["Required"] = "required";
+})(ElementDefinitionStrength = exports.ElementDefinitionStrength || (exports.ElementDefinitionStrength = {}));
+/** closed | open | openAtEnd */
+var ElementDefinitionRules;
+(function (ElementDefinitionRules) {
+    ElementDefinitionRules["Closed"] = "closed";
+    ElementDefinitionRules["Open"] = "open";
+    ElementDefinitionRules["OpenAtEnd"] = "openAtEnd";
+})(ElementDefinitionRules = exports.ElementDefinitionRules || (exports.ElementDefinitionRules = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Encounter.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Encounter.d.ts
index af06fa1..c22ad99 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Encounter.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Encounter.d.ts
@@ -8,18 +8,18 @@ import { Duration } from "./Duration";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** An interaction between a patient and healthcare provider(s) for the purpose of providing healthcare service(s) or assessing the health status of a patient. */
 export interface Encounter extends DomainResource {
+    resourceType: 'Encounter';
     /** The appointment that scheduled this encounter */
     appointment?: Array<Reference>;
     /** The list of diagnosis relevant to this encounter */
     diagnosis?: Array<EncounterDiagnosis>;
     _status?: Element;
     /** The organization (facility) responsible for this encounter */
-    serviceProvider?: Reference<"Organization">;
+    serviceProvider?: Reference<'Organization'>;
     /** Episode(s) of care that this encounter should be recorded against */
     episodeOfCare?: Array<Reference>;
     /** Coded reason the encounter takes place */
@@ -37,7 +37,7 @@ export interface Encounter extends DomainResource {
     /** Indicates the urgency of the encounter */
     priority?: CodeableConcept;
     /** planned | arrived | triaged | in-progress | onleave | finished | cancelled + */
-    status: code;
+    status: `${EncounterStatus}`;
     /** Classification of patient encounter */
     class: Coding;
     /** Quantity of time the encounter lasted (less time absent) */
@@ -51,11 +51,11 @@ export interface Encounter extends DomainResource {
     /** The ServiceRequest that initiated this encounter */
     basedOn?: Array<Reference>;
     /** Another Encounter this encounter is part of */
-    partOf?: Reference<"Encounter">;
+    partOf?: Reference<'Encounter'>;
     /** List of locations where the patient has been */
     location?: Array<EncounterLocation>;
     /** The patient or group present at the encounter */
-    subject?: Reference<"Patient" | "Group">;
+    subject?: Reference<'Patient' | 'Group'>;
     /** List of past encounter statuses */
     statusHistory?: Array<EncounterStatusHistory>;
     /** Reason the encounter takes place (reference) */
@@ -64,7 +64,7 @@ export interface Encounter extends DomainResource {
 /** The list of diagnosis relevant to this encounter */
 export interface EncounterDiagnosis extends BackboneElement {
     /** The diagnosis or procedure relevant to the encounter */
-    condition: Reference<"Procedure" | "Condition">;
+    condition: Reference<'Procedure' | 'Condition'>;
     /** Role that this diagnosis has within the encounter (e.g. admission, billing, discharge …) */
     use?: CodeableConcept;
     /** Ranking of the diagnosis (for each role type) */
@@ -78,7 +78,7 @@ export interface EncounterParticipant extends BackboneElement {
     /** Period of time during the encounter that the participant participated */
     period?: Period;
     /** Persons involved in the encounter other than the patient */
-    individual?: Reference<"PractitionerRole" | "Practitioner" | "RelatedPerson">;
+    individual?: Reference<'PractitionerRole' | 'Practitioner' | 'RelatedPerson'>;
 }
 /** List of past encounter classes */
 export interface EncounterClassHistory extends BackboneElement {
@@ -87,6 +87,18 @@ export interface EncounterClassHistory extends BackboneElement {
     /** The time that the episode was in the specified class */
     period: Period;
 }
+/** planned | arrived | triaged | in-progress | onleave | finished | cancelled + */
+export declare enum EncounterStatus {
+    Cancelled = "cancelled",
+    Arrived = "arrived",
+    Onleave = "onleave",
+    Triaged = "triaged",
+    Planned = "planned",
+    Unknown = "unknown",
+    InProgress = "in-progress",
+    EnteredInError = "entered-in-error",
+    Finished = "finished"
+}
 /** Details about the admission to a healthcare service */
 export interface EncounterHospitalization extends BackboneElement {
     /** Category or kind of location after discharge */
@@ -104,16 +116,16 @@ export interface EncounterHospitalization extends BackboneElement {
     /** The type of hospital re-admission that has occurred (if any). If the value is absent, then this is not identified as a readmission */
     reAdmission?: CodeableConcept;
     /** The location/organization from which the patient came before admission */
-    origin?: Reference<"Organization" | "Location">;
+    origin?: Reference<'Organization' | 'Location'>;
     /** Location/organization to which the patient is discharged */
-    destination?: Reference<"Organization" | "Location">;
+    destination?: Reference<'Organization' | 'Location'>;
 }
 /** List of locations where the patient has been */
 export interface EncounterLocation extends BackboneElement {
     /** Location the encounter takes place */
-    location: Reference<"Location">;
+    location: Reference<'Location'>;
     /** planned | active | reserved | completed */
-    status?: code;
+    status?: `${EncounterStatus}`;
     _status?: Element;
     /** The physical type of the location (usually the level in the location hierachy - bed room ward etc.) */
     physicalType?: CodeableConcept;
@@ -123,7 +135,7 @@ export interface EncounterLocation extends BackboneElement {
 /** List of past encounter statuses */
 export interface EncounterStatusHistory extends BackboneElement {
     /** planned | arrived | triaged | in-progress | onleave | finished | cancelled + */
-    status: code;
+    status: `${EncounterStatus}`;
     _status?: Element;
     /** The time that the episode was in the specified status */
     period: Period;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Encounter.js b/vendor/r4/types/hl7-fhir-r4-core/Encounter.js
index c8ad2e5..de47869 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Encounter.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Encounter.js
@@ -1,2 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncounterStatus = void 0;
+/** planned | arrived | triaged | in-progress | onleave | finished | cancelled + */
+var EncounterStatus;
+(function (EncounterStatus) {
+    EncounterStatus["Cancelled"] = "cancelled";
+    EncounterStatus["Arrived"] = "arrived";
+    EncounterStatus["Onleave"] = "onleave";
+    EncounterStatus["Triaged"] = "triaged";
+    EncounterStatus["Planned"] = "planned";
+    EncounterStatus["Unknown"] = "unknown";
+    EncounterStatus["InProgress"] = "in-progress";
+    EncounterStatus["EnteredInError"] = "entered-in-error";
+    EncounterStatus["Finished"] = "finished";
+})(EncounterStatus = exports.EncounterStatus || (exports.EncounterStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Endpoint.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Endpoint.d.ts
index 3218eff..0c46708 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Endpoint.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Endpoint.d.ts
@@ -12,13 +12,14 @@ import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** The technical details of an endpoint that can be used for electronic services, such as for web services providing XDS.b or a REST endpoint for another FHIR server. This may include any security context information. */
 export interface Endpoint extends DomainResource {
+    resourceType: 'Endpoint';
     _address?: Element;
     /** Protocol/Profile/Standard to be used with this endpoint connection */
     connectionType: Coding;
     /** The technical base address for connecting to this endpoint */
     address: url;
     /** Organization that manages this endpoint (might not be the organization that exposes the endpoint) */
-    managingOrganization?: Reference<"Organization">;
+    managingOrganization?: Reference<'Organization'>;
     /** A name that this endpoint can be identified by */
     name?: string;
     /** Mimetype to send. If not specified, the content could be anything (including no payload, if the connectionType defined this) */
@@ -30,7 +31,7 @@ export interface Endpoint extends DomainResource {
     /** Usage depends on the channel type */
     header?: Array<string>;
     /** active | suspended | error | off | entered-in-error | test */
-    status: code;
+    status: `${EndpointStatus}`;
     _name?: Element;
     /** Identifies this endpoint across multiple systems */
     identifier?: Array<Identifier>;
@@ -40,3 +41,12 @@ export interface Endpoint extends DomainResource {
     contact?: Array<ContactPoint>;
     _payloadMimeType?: Array<Element>;
 }
+/** active | suspended | error | off | entered-in-error | test */
+export declare enum EndpointStatus {
+    Active = "active",
+    EnteredInError = "entered-in-error",
+    Error = "error",
+    Off = "off",
+    Suspended = "suspended",
+    Test = "test"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Endpoint.js b/vendor/r4/types/hl7-fhir-r4-core/Endpoint.js
index c8ad2e5..8827b7b 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Endpoint.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Endpoint.js
@@ -1,2 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointStatus = void 0;
+/** active | suspended | error | off | entered-in-error | test */
+var EndpointStatus;
+(function (EndpointStatus) {
+    EndpointStatus["Active"] = "active";
+    EndpointStatus["EnteredInError"] = "entered-in-error";
+    EndpointStatus["Error"] = "error";
+    EndpointStatus["Off"] = "off";
+    EndpointStatus["Suspended"] = "suspended";
+    EndpointStatus["Test"] = "test";
+})(EndpointStatus = exports.EndpointStatus || (exports.EndpointStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/EnrollmentRequest.d.ts b/vendor/r4/types/hl7-fhir-r4-core/EnrollmentRequest.d.ts
index fad89b2..172ba1c 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/EnrollmentRequest.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/EnrollmentRequest.d.ts
@@ -4,24 +4,31 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** This resource provides the insurance enrollment details to the insurer regarding a specified coverage. */
 export interface EnrollmentRequest extends DomainResource {
+    resourceType: 'EnrollmentRequest';
     _created?: Element;
     /** The subject to be enrolled */
-    candidate?: Reference<"Patient">;
+    candidate?: Reference<'Patient'>;
     _status?: Element;
     /** Insurance information */
-    coverage?: Reference<"Coverage">;
+    coverage?: Reference<'Coverage'>;
     /** Creation date */
     created?: dateTime;
     /** Target */
-    insurer?: Reference<"Organization">;
+    insurer?: Reference<'Organization'>;
     /** active | cancelled | draft | entered-in-error */
-    status?: code;
+    status?: `${EnrollmentRequestStatus}`;
     /** Business Identifier */
     identifier?: Array<Identifier>;
     /** Responsible practitioner */
-    provider?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    provider?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
+}
+/** active | cancelled | draft | entered-in-error */
+export declare enum EnrollmentRequestStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    EnteredInError = "entered-in-error"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/EnrollmentRequest.js b/vendor/r4/types/hl7-fhir-r4-core/EnrollmentRequest.js
index c8ad2e5..1522891 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/EnrollmentRequest.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/EnrollmentRequest.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnrollmentRequestStatus = void 0;
+/** active | cancelled | draft | entered-in-error */
+var EnrollmentRequestStatus;
+(function (EnrollmentRequestStatus) {
+    EnrollmentRequestStatus["Active"] = "active";
+    EnrollmentRequestStatus["Cancelled"] = "cancelled";
+    EnrollmentRequestStatus["Draft"] = "draft";
+    EnrollmentRequestStatus["EnteredInError"] = "entered-in-error";
+})(EnrollmentRequestStatus = exports.EnrollmentRequestStatus || (exports.EnrollmentRequestStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/EnrollmentResponse.d.ts b/vendor/r4/types/hl7-fhir-r4-core/EnrollmentResponse.d.ts
index e5a88f2..972fb22 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/EnrollmentResponse.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/EnrollmentResponse.d.ts
@@ -4,28 +4,42 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource. */
 export interface EnrollmentResponse extends DomainResource {
+    resourceType: 'EnrollmentResponse';
     _created?: Element;
     /** Claim reference */
-    request?: Reference<"EnrollmentRequest">;
+    request?: Reference<'EnrollmentRequest'>;
     /** Responsible practitioner */
-    requestProvider?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    requestProvider?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     _disposition?: Element;
     _status?: Element;
     /** Creation date */
     created?: dateTime;
     /** queued | complete | error | partial */
-    outcome?: code;
+    outcome?: `${EnrollmentResponseOutcome}`;
     /** Insurer */
-    organization?: Reference<"Organization">;
+    organization?: Reference<'Organization'>;
     _outcome?: Element;
     /** Disposition Message */
     disposition?: string;
     /** active | cancelled | draft | entered-in-error */
-    status?: code;
+    status?: `${EnrollmentResponseStatus}`;
     /** Business Identifier */
     identifier?: Array<Identifier>;
 }
+/** queued | complete | error | partial */
+export declare enum EnrollmentResponseOutcome {
+    Complete = "complete",
+    Error = "error",
+    Partial = "partial",
+    Queued = "queued"
+}
+/** active | cancelled | draft | entered-in-error */
+export declare enum EnrollmentResponseStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    EnteredInError = "entered-in-error"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/EnrollmentResponse.js b/vendor/r4/types/hl7-fhir-r4-core/EnrollmentResponse.js
index c8ad2e5..dd9e626 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/EnrollmentResponse.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/EnrollmentResponse.js
@@ -1,2 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnrollmentResponseStatus = exports.EnrollmentResponseOutcome = void 0;
+/** queued | complete | error | partial */
+var EnrollmentResponseOutcome;
+(function (EnrollmentResponseOutcome) {
+    EnrollmentResponseOutcome["Complete"] = "complete";
+    EnrollmentResponseOutcome["Error"] = "error";
+    EnrollmentResponseOutcome["Partial"] = "partial";
+    EnrollmentResponseOutcome["Queued"] = "queued";
+})(EnrollmentResponseOutcome = exports.EnrollmentResponseOutcome || (exports.EnrollmentResponseOutcome = {}));
+/** active | cancelled | draft | entered-in-error */
+var EnrollmentResponseStatus;
+(function (EnrollmentResponseStatus) {
+    EnrollmentResponseStatus["Active"] = "active";
+    EnrollmentResponseStatus["Cancelled"] = "cancelled";
+    EnrollmentResponseStatus["Draft"] = "draft";
+    EnrollmentResponseStatus["EnteredInError"] = "entered-in-error";
+})(EnrollmentResponseStatus = exports.EnrollmentResponseStatus || (exports.EnrollmentResponseStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/EpisodeOfCare.d.ts b/vendor/r4/types/hl7-fhir-r4-core/EpisodeOfCare.d.ts
index ae76842..b9d3dda 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/EpisodeOfCare.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/EpisodeOfCare.d.ts
@@ -6,17 +6,17 @@ import { CodeableConcept } from "./CodeableConcept";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** An association between a patient and an organization / healthcare provider(s) during which time encounters may occur. The managing organization assumes a level of responsibility for the patient during this time. */
 export interface EpisodeOfCare extends DomainResource {
+    resourceType: 'EpisodeOfCare';
     /** The patient who is the focus of this episode of care */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** The list of diagnosis relevant to this episode of care */
     diagnosis?: Array<EpisodeOfCareDiagnosis>;
     /** Organization that assumes care */
-    managingOrganization?: Reference<"Organization">;
+    managingOrganization?: Reference<'Organization'>;
     _status?: Element;
     /** Type/class  - e.g. specialist referral, disease management */
     type?: Array<CodeableConcept>;
@@ -27,30 +27,40 @@ export interface EpisodeOfCare extends DomainResource {
     /** Other practitioners facilitating this episode of care */
     team?: Array<Reference>;
     /** planned | waitlist | active | onhold | finished | cancelled | entered-in-error */
-    status: code;
+    status: `${EpisodeOfCareStatus}`;
     /** Business Identifier(s) relevant for this EpisodeOfCare */
     identifier?: Array<Identifier>;
     /** Interval during responsibility is assumed */
     period?: Period;
     /** Care manager/care coordinator for the patient */
-    careManager?: Reference<"PractitionerRole" | "Practitioner">;
+    careManager?: Reference<'PractitionerRole' | 'Practitioner'>;
     /** Past list of status codes (the current status may be included to cover the start date of the status) */
     statusHistory?: Array<EpisodeOfCareStatusHistory>;
 }
 /** The list of diagnosis relevant to this episode of care */
 export interface EpisodeOfCareDiagnosis extends BackboneElement {
     /** Conditions/problems/diagnoses this episode of care is for */
-    condition: Reference<"Condition">;
+    condition: Reference<'Condition'>;
     /** Role that this diagnosis has within the episode of care (e.g. admission, billing, discharge …) */
     role?: CodeableConcept;
     /** Ranking of the diagnosis (for each role type) */
     rank?: positiveInt;
     _rank?: Element;
 }
+/** planned | waitlist | active | onhold | finished | cancelled | entered-in-error */
+export declare enum EpisodeOfCareStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    EnteredInError = "entered-in-error",
+    Finished = "finished",
+    Onhold = "onhold",
+    Planned = "planned",
+    Waitlist = "waitlist"
+}
 /** Past list of status codes (the current status may be included to cover the start date of the status) */
 export interface EpisodeOfCareStatusHistory extends BackboneElement {
     /** planned | waitlist | active | onhold | finished | cancelled | entered-in-error */
-    status: code;
+    status: `${EpisodeOfCareStatus}`;
     _status?: Element;
     /** Duration the EpisodeOfCare was in the specified status */
     period: Period;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/EpisodeOfCare.js b/vendor/r4/types/hl7-fhir-r4-core/EpisodeOfCare.js
index c8ad2e5..e92fc91 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/EpisodeOfCare.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/EpisodeOfCare.js
@@ -1,2 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpisodeOfCareStatus = void 0;
+/** planned | waitlist | active | onhold | finished | cancelled | entered-in-error */
+var EpisodeOfCareStatus;
+(function (EpisodeOfCareStatus) {
+    EpisodeOfCareStatus["Active"] = "active";
+    EpisodeOfCareStatus["Cancelled"] = "cancelled";
+    EpisodeOfCareStatus["EnteredInError"] = "entered-in-error";
+    EpisodeOfCareStatus["Finished"] = "finished";
+    EpisodeOfCareStatus["Onhold"] = "onhold";
+    EpisodeOfCareStatus["Planned"] = "planned";
+    EpisodeOfCareStatus["Waitlist"] = "waitlist";
+})(EpisodeOfCareStatus = exports.EpisodeOfCareStatus || (exports.EpisodeOfCareStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/EventDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/EventDefinition.d.ts
index 318b9fc..55ab7d7 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/EventDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/EventDefinition.d.ts
@@ -13,10 +13,10 @@ import { date } from "./date";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** The EventDefinition resource provides a reusable description of when a particular event can occur. */
 export interface EventDefinition extends DomainResource {
+    resourceType: 'EventDefinition';
     /** Natural language description of the event definition */
     description?: markdown;
     _usage?: Element;
@@ -58,7 +58,7 @@ export interface EventDefinition extends DomainResource {
     usage?: string;
     _lastReviewDate?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${EventDefinitionStatus}`;
     /** Subordinate title of the event definition */
     subtitle?: string;
     _name?: Element;
@@ -84,8 +84,15 @@ export interface EventDefinition extends DomainResource {
     relatedArtifact?: Array<RelatedArtifact>;
     /** Contact details for the publisher */
     contact?: Array<ContactDetail>;
-    subjectReference?: Reference<"Group">;
+    subjectReference?: Reference<'Group'>;
     _url?: Element;
     /** When the event definition is expected to be used */
     effectivePeriod?: Period;
 }
+/** draft | active | retired | unknown */
+export declare enum EventDefinitionStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/EventDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/EventDefinition.js
index c8ad2e5..8c3ea0d 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/EventDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/EventDefinition.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventDefinitionStatus = void 0;
+/** draft | active | retired | unknown */
+var EventDefinitionStatus;
+(function (EventDefinitionStatus) {
+    EventDefinitionStatus["Active"] = "active";
+    EventDefinitionStatus["Draft"] = "draft";
+    EventDefinitionStatus["Retired"] = "retired";
+    EventDefinitionStatus["Unknown"] = "unknown";
+})(EventDefinitionStatus = exports.EventDefinitionStatus || (exports.EventDefinitionStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Evidence.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Evidence.d.ts
index 2982629..8f1574a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Evidence.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Evidence.d.ts
@@ -13,10 +13,10 @@ import { date } from "./date";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** The Evidence resource describes the conditional state (population and any exposures being compared within the population) and outcome (if specified) that the knowledge (evidence, assertion, recommendation) is about. */
 export interface Evidence extends DomainResource {
+    resourceType: 'Evidence';
     /** Natural language description of the evidence */
     description?: markdown;
     /** Date last changed */
@@ -52,7 +52,7 @@ export interface Evidence extends DomainResource {
     author?: Array<ContactDetail>;
     _lastReviewDate?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${EvidenceStatus}`;
     /** Subordinate title of the Evidence */
     subtitle?: string;
     _name?: Element;
@@ -80,10 +80,17 @@ export interface Evidence extends DomainResource {
     /** Contact details for the publisher */
     contact?: Array<ContactDetail>;
     /** What population? */
-    exposureBackground: Reference<"EvidenceVariable">;
+    exposureBackground: Reference<'EvidenceVariable'>;
     _url?: Element;
     /** When the evidence is expected to be used */
     effectivePeriod?: Period;
     /** What exposure? */
     exposureVariant?: Array<Reference>;
 }
+/** draft | active | retired | unknown */
+export declare enum EvidenceStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Evidence.js b/vendor/r4/types/hl7-fhir-r4-core/Evidence.js
index c8ad2e5..d02231c 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Evidence.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Evidence.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceStatus = void 0;
+/** draft | active | retired | unknown */
+var EvidenceStatus;
+(function (EvidenceStatus) {
+    EvidenceStatus["Active"] = "active";
+    EvidenceStatus["Draft"] = "draft";
+    EvidenceStatus["Retired"] = "retired";
+    EvidenceStatus["Unknown"] = "unknown";
+})(EvidenceStatus = exports.EvidenceStatus || (exports.EvidenceStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/EvidenceVariable.d.ts b/vendor/r4/types/hl7-fhir-r4-core/EvidenceVariable.d.ts
index bcba398..918f0a9 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/EvidenceVariable.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/EvidenceVariable.d.ts
@@ -19,11 +19,11 @@ import { date } from "./date";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** The EvidenceVariable resource describes a "PICO" element that knowledge (evidence, assertion, recommendation) is about. */
 export interface EvidenceVariable extends DomainResource {
+    resourceType: 'EvidenceVariable';
     /** Natural language description of the evidence variable */
     description?: markdown;
     /** Date last changed */
@@ -48,7 +48,7 @@ export interface EvidenceVariable extends DomainResource {
     copyright?: markdown;
     _approvalDate?: Element;
     /** dichotomous | continuous | descriptive */
-    type?: code;
+    type?: `${EvidenceVariableType}`;
     /** The category of the EvidenceVariable, such as Education, Treatment, Assessment, etc. */
     topic?: Array<CodeableConcept>;
     /** Name for this evidence variable (human friendly) */
@@ -62,7 +62,7 @@ export interface EvidenceVariable extends DomainResource {
     characteristic: Array<EvidenceVariableCharacteristic>;
     _lastReviewDate?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${EvidenceVariableStatus}`;
     /** Subordinate title of the EvidenceVariable */
     subtitle?: string;
     _name?: Element;
@@ -93,6 +93,21 @@ export interface EvidenceVariable extends DomainResource {
     /** When the evidence variable is expected to be used */
     effectivePeriod?: Period;
 }
+/** dichotomous | continuous | descriptive */
+export declare enum EvidenceVariableType {
+    Continuous = "continuous",
+    Descriptive = "descriptive",
+    Dichotomous = "dichotomous"
+}
+/** mean | median | mean-of-mean | mean-of-median | median-of-mean | median-of-median */
+export declare enum EvidenceVariableGroupMeasure {
+    Mean = "mean",
+    MeanOfMean = "mean-of-mean",
+    MeanOfMedian = "mean-of-median",
+    Median = "median",
+    MedianOfMean = "median-of-mean",
+    MedianOfMedian = "median-of-median"
+}
 /** What defines the members of the evidence element */
 export interface EvidenceVariableCharacteristic extends BackboneElement {
     /** Natural language description of the characteristic */
@@ -100,7 +115,7 @@ export interface EvidenceVariableCharacteristic extends BackboneElement {
     /** Whether the characteristic includes or excludes members */
     exclude?: boolean;
     /** mean | median | mean-of-mean | mean-of-median | median-of-mean | median-of-median */
-    groupMeasure?: code;
+    groupMeasure?: `${EvidenceVariableGroupMeasure}`;
     definitionExpression: Expression;
     /** Observation time from study start */
     timeFromStart?: Duration;
@@ -108,7 +123,7 @@ export interface EvidenceVariableCharacteristic extends BackboneElement {
     definitionDataRequirement: DataRequirement;
     definitionTriggerDefinition: TriggerDefinition;
     definitionCanonical: canonical;
-    definitionReference: Reference<"Group">;
+    definitionReference: Reference<'Group'>;
     _groupMeasure?: Element;
     participantEffectiveTiming?: Timing;
     participantEffectiveDateTime?: dateTime;
@@ -121,3 +136,10 @@ export interface EvidenceVariableCharacteristic extends BackboneElement {
     /** What code/value pairs define members? */
     usageContext?: Array<UsageContext>;
 }
+/** draft | active | retired | unknown */
+export declare enum EvidenceVariableStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/EvidenceVariable.js b/vendor/r4/types/hl7-fhir-r4-core/EvidenceVariable.js
index c8ad2e5..78d80b4 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/EvidenceVariable.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/EvidenceVariable.js
@@ -1,2 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceVariableStatus = exports.EvidenceVariableGroupMeasure = exports.EvidenceVariableType = void 0;
+/** dichotomous | continuous | descriptive */
+var EvidenceVariableType;
+(function (EvidenceVariableType) {
+    EvidenceVariableType["Continuous"] = "continuous";
+    EvidenceVariableType["Descriptive"] = "descriptive";
+    EvidenceVariableType["Dichotomous"] = "dichotomous";
+})(EvidenceVariableType = exports.EvidenceVariableType || (exports.EvidenceVariableType = {}));
+/** mean | median | mean-of-mean | mean-of-median | median-of-mean | median-of-median */
+var EvidenceVariableGroupMeasure;
+(function (EvidenceVariableGroupMeasure) {
+    EvidenceVariableGroupMeasure["Mean"] = "mean";
+    EvidenceVariableGroupMeasure["MeanOfMean"] = "mean-of-mean";
+    EvidenceVariableGroupMeasure["MeanOfMedian"] = "mean-of-median";
+    EvidenceVariableGroupMeasure["Median"] = "median";
+    EvidenceVariableGroupMeasure["MedianOfMean"] = "median-of-mean";
+    EvidenceVariableGroupMeasure["MedianOfMedian"] = "median-of-median";
+})(EvidenceVariableGroupMeasure = exports.EvidenceVariableGroupMeasure || (exports.EvidenceVariableGroupMeasure = {}));
+/** draft | active | retired | unknown */
+var EvidenceVariableStatus;
+(function (EvidenceVariableStatus) {
+    EvidenceVariableStatus["Active"] = "active";
+    EvidenceVariableStatus["Draft"] = "draft";
+    EvidenceVariableStatus["Retired"] = "retired";
+    EvidenceVariableStatus["Unknown"] = "unknown";
+})(EvidenceVariableStatus = exports.EvidenceVariableStatus || (exports.EvidenceVariableStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ExampleScenario.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ExampleScenario.d.ts
index c4f7798..fc2fdff 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ExampleScenario.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ExampleScenario.d.ts
@@ -9,11 +9,11 @@ import { canonical } from "./canonical";
 import { DomainResource } from "./DomainResource";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Example of workflow instance. */
 export interface ExampleScenario extends DomainResource {
+    resourceType: 'ExampleScenario';
     /** Date last changed */
     date?: dateTime;
     /** Name of the publisher (organization or individual) */
@@ -42,7 +42,7 @@ export interface ExampleScenario extends DomainResource {
     /** Another nested workflow */
     workflow?: Array<canonical>;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${ExampleScenarioStatus}`;
     _name?: Element;
     /** Canonical identifier for this example scenario, represented as a URI (globally unique) */
     url?: uri;
@@ -58,6 +58,21 @@ export interface ExampleScenario extends DomainResource {
     /** Actor participating in the resource */
     actor?: Array<ExampleScenarioActor>;
 }
+/** Actor participating in the resource */
+export interface ExampleScenarioActor extends BackboneElement {
+    /** ID or acronym of the actor */
+    actorId: string;
+    _actorId?: Element;
+    /** person | entity */
+    type: `${ExampleScenarioType}`;
+    _type?: Element;
+    /** The name of the actor as shown in the page */
+    name?: string;
+    _name?: Element;
+    /** The description of the actor */
+    description?: markdown;
+    _description?: Element;
+}
 /** A specific version of the resource */
 export interface ExampleScenarioVersion extends BackboneElement {
     /** The identifier of a specific version of a resource */
@@ -67,6 +82,17 @@ export interface ExampleScenarioVersion extends BackboneElement {
     description: markdown;
     _description?: Element;
 }
+/** Alternate non-typical step action */
+export interface ExampleScenarioProcessStepAlternative extends BackboneElement {
+    /** Label for alternative */
+    title: string;
+    _title?: Element;
+    /** A human-readable description of each option */
+    description?: markdown;
+    _description?: Element;
+    /** What happens in each alternative option */
+    step?: Array<ExampleScenarioProcessStep>;
+}
 /** Each resource and each version that is present in the workflow */
 export interface ExampleScenarioInstance extends BackboneElement {
     /** Human-friendly description of the resource instance */
@@ -76,7 +102,7 @@ export interface ExampleScenarioInstance extends BackboneElement {
     name?: string;
     _resourceId?: Element;
     /** The type of the resource */
-    resourceType: code;
+    resourceType: `${ExampleScenarioResourceType}`;
     _resourceType?: Element;
     _description?: Element;
     /** The id of the resource for referencing */
@@ -85,20 +111,10 @@ export interface ExampleScenarioInstance extends BackboneElement {
     /** A specific version of the resource */
     version?: Array<ExampleScenarioVersion>;
 }
-/** Actor participating in the resource */
-export interface ExampleScenarioActor extends BackboneElement {
-    /** ID or acronym of the actor */
-    actorId: string;
-    _actorId?: Element;
-    /** person | entity */
-    type: code;
-    _type?: Element;
-    /** The name of the actor as shown in the page */
-    name?: string;
-    _name?: Element;
-    /** The description of the actor */
-    description?: markdown;
-    _description?: Element;
+/** person | entity */
+export declare enum ExampleScenarioType {
+    Entity = "entity",
+    Person = "person"
 }
 /** Each major process - a group of operations */
 export interface ExampleScenarioProcess extends BackboneElement {
@@ -116,15 +132,6 @@ export interface ExampleScenarioProcess extends BackboneElement {
     _title?: Element;
     step?: Array<ExampleScenarioProcessStep>;
 }
-/** Resources contained in the instance */
-export interface ExampleScenarioInstanceContainedInstance extends BackboneElement {
-    /** Each resource contained in the instance */
-    resourceId: string;
-    _resourceId?: Element;
-    /** A specific version of a resource contained in the instance */
-    versionId?: string;
-    _versionId?: Element;
-}
 /** Each interaction or action */
 export interface ExampleScenarioProcessStepOperation extends BackboneElement {
     /** Each resource instance used by the responder */
@@ -156,16 +163,163 @@ export interface ExampleScenarioProcessStepOperation extends BackboneElement {
     /** Who receives the transaction */
     receiver?: string;
 }
-/** Alternate non-typical step action */
-export interface ExampleScenarioProcessStepAlternative extends BackboneElement {
-    /** Label for alternative */
-    title: string;
-    _title?: Element;
-    /** A human-readable description of each option */
-    description?: markdown;
-    _description?: Element;
-    /** What happens in each alternative option */
-    step?: Array<ExampleScenarioProcessStep>;
+/** The type of the resource */
+export declare enum ExampleScenarioResourceType {
+    ImmunizationEvaluation = "ImmunizationEvaluation",
+    Appointment = "Appointment",
+    StructureMap = "StructureMap",
+    CareTeam = "CareTeam",
+    Linkage = "Linkage",
+    Communication = "Communication",
+    MedicationDispense = "MedicationDispense",
+    ImagingStudy = "ImagingStudy",
+    ChargeItem = "ChargeItem",
+    AdverseEvent = "AdverseEvent",
+    Media = "Media",
+    SubstancePolymer = "SubstancePolymer",
+    QuestionnaireResponse = "QuestionnaireResponse",
+    Coverage = "Coverage",
+    Procedure = "Procedure",
+    AuditEvent = "AuditEvent",
+    PaymentReconciliation = "PaymentReconciliation",
+    MedicinalProductManufactured = "MedicinalProductManufactured",
+    CompartmentDefinition = "CompartmentDefinition",
+    Organization = "Organization",
+    ExplanationOfBenefit = "ExplanationOfBenefit",
+    Composition = "Composition",
+    CoverageEligibilityResponse = "CoverageEligibilityResponse",
+    DocumentReference = "DocumentReference",
+    EventDefinition = "EventDefinition",
+    SubstanceProtein = "SubstanceProtein",
+    TerminologyCapabilities = "TerminologyCapabilities",
+    Encounter = "Encounter",
+    ImplementationGuide = "ImplementationGuide",
+    EvidenceVariable = "EvidenceVariable",
+    ObservationDefinition = "ObservationDefinition",
+    DiagnosticReport = "DiagnosticReport",
+    ExampleScenario = "ExampleScenario",
+    ResearchDefinition = "ResearchDefinition",
+    Parameters = "Parameters",
+    SearchParameter = "SearchParameter",
+    MedicinalProductInteraction = "MedicinalProductInteraction",
+    CodeSystem = "CodeSystem",
+    MessageDefinition = "MessageDefinition",
+    NutritionOrder = "NutritionOrder",
+    VerificationResult = "VerificationResult",
+    MedicationAdministration = "MedicationAdministration",
+    CatalogEntry = "CatalogEntry",
+    Flag = "Flag",
+    DeviceUseStatement = "DeviceUseStatement",
+    Contract = "Contract",
+    Invoice = "Invoice",
+    PaymentNotice = "PaymentNotice",
+    Location = "Location",
+    Claim = "Claim",
+    Specimen = "Specimen",
+    MedicationStatement = "MedicationStatement",
+    EnrollmentResponse = "EnrollmentResponse",
+    Evidence = "Evidence",
+    Bundle = "Bundle",
+    ResearchElementDefinition = "ResearchElementDefinition",
+    BodyStructure = "BodyStructure",
+    MedicinalProduct = "MedicinalProduct",
+    ResearchStudy = "ResearchStudy",
+    AppointmentResponse = "AppointmentResponse",
+    MedicinalProductIndication = "MedicinalProductIndication",
+    Measure = "Measure",
+    Person = "Person",
+    InsurancePlan = "InsurancePlan",
+    Patient = "Patient",
+    EffectEvidenceSynthesis = "EffectEvidenceSynthesis",
+    ResearchSubject = "ResearchSubject",
+    Medication = "Medication",
+    ConceptMap = "ConceptMap",
+    CoverageEligibilityRequest = "CoverageEligibilityRequest",
+    SubstanceSourceMaterial = "SubstanceSourceMaterial",
+    VisionPrescription = "VisionPrescription",
+    MolecularSequence = "MolecularSequence",
+    MedicinalProductUndesirableEffect = "MedicinalProductUndesirableEffect",
+    OperationOutcome = "OperationOutcome",
+    MessageHeader = "MessageHeader",
+    AllergyIntolerance = "AllergyIntolerance",
+    SubstanceReferenceInformation = "SubstanceReferenceInformation",
+    SupplyDelivery = "SupplyDelivery",
+    EpisodeOfCare = "EpisodeOfCare",
+    PractitionerRole = "PractitionerRole",
+    Library = "Library",
+    Practitioner = "Practitioner",
+    MedicationRequest = "MedicationRequest",
+    ImmunizationRecommendation = "ImmunizationRecommendation",
+    Immunization = "Immunization",
+    GraphDefinition = "GraphDefinition",
+    Account = "Account",
+    MedicinalProductIngredient = "MedicinalProductIngredient",
+    MeasureReport = "MeasureReport",
+    DeviceMetric = "DeviceMetric",
+    Goal = "Goal",
+    MedicationKnowledge = "MedicationKnowledge",
+    ClaimResponse = "ClaimResponse",
+    DeviceDefinition = "DeviceDefinition",
+    Slot = "Slot",
+    ValueSet = "ValueSet",
+    MedicinalProductAuthorization = "MedicinalProductAuthorization",
+    StructureDefinition = "StructureDefinition",
+    MedicinalProductContraindication = "MedicinalProductContraindication",
+    DeviceRequest = "DeviceRequest",
+    List = "List",
+    Questionnaire = "Questionnaire",
+    DomainResource = "DomainResource",
+    Endpoint = "Endpoint",
+    NamingSystem = "NamingSystem",
+    MedicinalProductPackaged = "MedicinalProductPackaged",
+    Basic = "Basic",
+    Binary = "Binary",
+    PlanDefinition = "PlanDefinition",
+    Subscription = "Subscription",
+    RelatedPerson = "RelatedPerson",
+    SubstanceSpecification = "SubstanceSpecification",
+    SubstanceNucleicAcid = "SubstanceNucleicAcid",
+    GuidanceResponse = "GuidanceResponse",
+    ClinicalImpression = "ClinicalImpression",
+    OrganizationAffiliation = "OrganizationAffiliation",
+    Resource = "Resource",
+    Condition = "Condition",
+    CapabilityStatement = "CapabilityStatement",
+    HealthcareService = "HealthcareService",
+    SpecimenDefinition = "SpecimenDefinition",
+    RiskAssessment = "RiskAssessment",
+    OperationDefinition = "OperationDefinition",
+    ActivityDefinition = "ActivityDefinition",
+    Schedule = "Schedule",
+    BiologicallyDerivedProduct = "BiologicallyDerivedProduct",
+    Group = "Group",
+    MedicinalProductPharmaceutical = "MedicinalProductPharmaceutical",
+    FamilyMemberHistory = "FamilyMemberHistory",
+    ServiceRequest = "ServiceRequest",
+    DetectedIssue = "DetectedIssue",
+    Device = "Device",
+    RequestGroup = "RequestGroup",
+    TestScript = "TestScript",
+    RiskEvidenceSynthesis = "RiskEvidenceSynthesis",
+    SupplyRequest = "SupplyRequest",
+    Task = "Task",
+    CommunicationRequest = "CommunicationRequest",
+    EnrollmentRequest = "EnrollmentRequest",
+    ChargeItemDefinition = "ChargeItemDefinition",
+    Substance = "Substance",
+    Provenance = "Provenance",
+    Consent = "Consent",
+    CarePlan = "CarePlan",
+    TestReport = "TestReport",
+    Observation = "Observation",
+    DocumentManifest = "DocumentManifest"
+}
+/** draft | active | retired | unknown */
+export declare enum ExampleScenarioStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
 }
 /** Each step of the process */
 export interface ExampleScenarioProcessStep extends BackboneElement {
@@ -179,3 +333,12 @@ export interface ExampleScenarioProcessStep extends BackboneElement {
     /** Alternate non-typical step action */
     alternative?: Array<ExampleScenarioProcessStepAlternative>;
 }
+/** Resources contained in the instance */
+export interface ExampleScenarioInstanceContainedInstance extends BackboneElement {
+    /** Each resource contained in the instance */
+    resourceId: string;
+    _resourceId?: Element;
+    /** A specific version of a resource contained in the instance */
+    versionId?: string;
+    _versionId?: Element;
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ExampleScenario.js b/vendor/r4/types/hl7-fhir-r4-core/ExampleScenario.js
index c8ad2e5..95de4c4 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ExampleScenario.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ExampleScenario.js
@@ -1,2 +1,169 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExampleScenarioStatus = exports.ExampleScenarioResourceType = exports.ExampleScenarioType = void 0;
+/** person | entity */
+var ExampleScenarioType;
+(function (ExampleScenarioType) {
+    ExampleScenarioType["Entity"] = "entity";
+    ExampleScenarioType["Person"] = "person";
+})(ExampleScenarioType = exports.ExampleScenarioType || (exports.ExampleScenarioType = {}));
+/** The type of the resource */
+var ExampleScenarioResourceType;
+(function (ExampleScenarioResourceType) {
+    ExampleScenarioResourceType["ImmunizationEvaluation"] = "ImmunizationEvaluation";
+    ExampleScenarioResourceType["Appointment"] = "Appointment";
+    ExampleScenarioResourceType["StructureMap"] = "StructureMap";
+    ExampleScenarioResourceType["CareTeam"] = "CareTeam";
+    ExampleScenarioResourceType["Linkage"] = "Linkage";
+    ExampleScenarioResourceType["Communication"] = "Communication";
+    ExampleScenarioResourceType["MedicationDispense"] = "MedicationDispense";
+    ExampleScenarioResourceType["ImagingStudy"] = "ImagingStudy";
+    ExampleScenarioResourceType["ChargeItem"] = "ChargeItem";
+    ExampleScenarioResourceType["AdverseEvent"] = "AdverseEvent";
+    ExampleScenarioResourceType["Media"] = "Media";
+    ExampleScenarioResourceType["SubstancePolymer"] = "SubstancePolymer";
+    ExampleScenarioResourceType["QuestionnaireResponse"] = "QuestionnaireResponse";
+    ExampleScenarioResourceType["Coverage"] = "Coverage";
+    ExampleScenarioResourceType["Procedure"] = "Procedure";
+    ExampleScenarioResourceType["AuditEvent"] = "AuditEvent";
+    ExampleScenarioResourceType["PaymentReconciliation"] = "PaymentReconciliation";
+    ExampleScenarioResourceType["MedicinalProductManufactured"] = "MedicinalProductManufactured";
+    ExampleScenarioResourceType["CompartmentDefinition"] = "CompartmentDefinition";
+    ExampleScenarioResourceType["Organization"] = "Organization";
+    ExampleScenarioResourceType["ExplanationOfBenefit"] = "ExplanationOfBenefit";
+    ExampleScenarioResourceType["Composition"] = "Composition";
+    ExampleScenarioResourceType["CoverageEligibilityResponse"] = "CoverageEligibilityResponse";
+    ExampleScenarioResourceType["DocumentReference"] = "DocumentReference";
+    ExampleScenarioResourceType["EventDefinition"] = "EventDefinition";
+    ExampleScenarioResourceType["SubstanceProtein"] = "SubstanceProtein";
+    ExampleScenarioResourceType["TerminologyCapabilities"] = "TerminologyCapabilities";
+    ExampleScenarioResourceType["Encounter"] = "Encounter";
+    ExampleScenarioResourceType["ImplementationGuide"] = "ImplementationGuide";
+    ExampleScenarioResourceType["EvidenceVariable"] = "EvidenceVariable";
+    ExampleScenarioResourceType["ObservationDefinition"] = "ObservationDefinition";
+    ExampleScenarioResourceType["DiagnosticReport"] = "DiagnosticReport";
+    ExampleScenarioResourceType["ExampleScenario"] = "ExampleScenario";
+    ExampleScenarioResourceType["ResearchDefinition"] = "ResearchDefinition";
+    ExampleScenarioResourceType["Parameters"] = "Parameters";
+    ExampleScenarioResourceType["SearchParameter"] = "SearchParameter";
+    ExampleScenarioResourceType["MedicinalProductInteraction"] = "MedicinalProductInteraction";
+    ExampleScenarioResourceType["CodeSystem"] = "CodeSystem";
+    ExampleScenarioResourceType["MessageDefinition"] = "MessageDefinition";
+    ExampleScenarioResourceType["NutritionOrder"] = "NutritionOrder";
+    ExampleScenarioResourceType["VerificationResult"] = "VerificationResult";
+    ExampleScenarioResourceType["MedicationAdministration"] = "MedicationAdministration";
+    ExampleScenarioResourceType["CatalogEntry"] = "CatalogEntry";
+    ExampleScenarioResourceType["Flag"] = "Flag";
+    ExampleScenarioResourceType["DeviceUseStatement"] = "DeviceUseStatement";
+    ExampleScenarioResourceType["Contract"] = "Contract";
+    ExampleScenarioResourceType["Invoice"] = "Invoice";
+    ExampleScenarioResourceType["PaymentNotice"] = "PaymentNotice";
+    ExampleScenarioResourceType["Location"] = "Location";
+    ExampleScenarioResourceType["Claim"] = "Claim";
+    ExampleScenarioResourceType["Specimen"] = "Specimen";
+    ExampleScenarioResourceType["MedicationStatement"] = "MedicationStatement";
+    ExampleScenarioResourceType["EnrollmentResponse"] = "EnrollmentResponse";
+    ExampleScenarioResourceType["Evidence"] = "Evidence";
+    ExampleScenarioResourceType["Bundle"] = "Bundle";
+    ExampleScenarioResourceType["ResearchElementDefinition"] = "ResearchElementDefinition";
+    ExampleScenarioResourceType["BodyStructure"] = "BodyStructure";
+    ExampleScenarioResourceType["MedicinalProduct"] = "MedicinalProduct";
+    ExampleScenarioResourceType["ResearchStudy"] = "ResearchStudy";
+    ExampleScenarioResourceType["AppointmentResponse"] = "AppointmentResponse";
+    ExampleScenarioResourceType["MedicinalProductIndication"] = "MedicinalProductIndication";
+    ExampleScenarioResourceType["Measure"] = "Measure";
+    ExampleScenarioResourceType["Person"] = "Person";
+    ExampleScenarioResourceType["InsurancePlan"] = "InsurancePlan";
+    ExampleScenarioResourceType["Patient"] = "Patient";
+    ExampleScenarioResourceType["EffectEvidenceSynthesis"] = "EffectEvidenceSynthesis";
+    ExampleScenarioResourceType["ResearchSubject"] = "ResearchSubject";
+    ExampleScenarioResourceType["Medication"] = "Medication";
+    ExampleScenarioResourceType["ConceptMap"] = "ConceptMap";
+    ExampleScenarioResourceType["CoverageEligibilityRequest"] = "CoverageEligibilityRequest";
+    ExampleScenarioResourceType["SubstanceSourceMaterial"] = "SubstanceSourceMaterial";
+    ExampleScenarioResourceType["VisionPrescription"] = "VisionPrescription";
+    ExampleScenarioResourceType["MolecularSequence"] = "MolecularSequence";
+    ExampleScenarioResourceType["MedicinalProductUndesirableEffect"] = "MedicinalProductUndesirableEffect";
+    ExampleScenarioResourceType["OperationOutcome"] = "OperationOutcome";
+    ExampleScenarioResourceType["MessageHeader"] = "MessageHeader";
+    ExampleScenarioResourceType["AllergyIntolerance"] = "AllergyIntolerance";
+    ExampleScenarioResourceType["SubstanceReferenceInformation"] = "SubstanceReferenceInformation";
+    ExampleScenarioResourceType["SupplyDelivery"] = "SupplyDelivery";
+    ExampleScenarioResourceType["EpisodeOfCare"] = "EpisodeOfCare";
+    ExampleScenarioResourceType["PractitionerRole"] = "PractitionerRole";
+    ExampleScenarioResourceType["Library"] = "Library";
+    ExampleScenarioResourceType["Practitioner"] = "Practitioner";
+    ExampleScenarioResourceType["MedicationRequest"] = "MedicationRequest";
+    ExampleScenarioResourceType["ImmunizationRecommendation"] = "ImmunizationRecommendation";
+    ExampleScenarioResourceType["Immunization"] = "Immunization";
+    ExampleScenarioResourceType["GraphDefinition"] = "GraphDefinition";
+    ExampleScenarioResourceType["Account"] = "Account";
+    ExampleScenarioResourceType["MedicinalProductIngredient"] = "MedicinalProductIngredient";
+    ExampleScenarioResourceType["MeasureReport"] = "MeasureReport";
+    ExampleScenarioResourceType["DeviceMetric"] = "DeviceMetric";
+    ExampleScenarioResourceType["Goal"] = "Goal";
+    ExampleScenarioResourceType["MedicationKnowledge"] = "MedicationKnowledge";
+    ExampleScenarioResourceType["ClaimResponse"] = "ClaimResponse";
+    ExampleScenarioResourceType["DeviceDefinition"] = "DeviceDefinition";
+    ExampleScenarioResourceType["Slot"] = "Slot";
+    ExampleScenarioResourceType["ValueSet"] = "ValueSet";
+    ExampleScenarioResourceType["MedicinalProductAuthorization"] = "MedicinalProductAuthorization";
+    ExampleScenarioResourceType["StructureDefinition"] = "StructureDefinition";
+    ExampleScenarioResourceType["MedicinalProductContraindication"] = "MedicinalProductContraindication";
+    ExampleScenarioResourceType["DeviceRequest"] = "DeviceRequest";
+    ExampleScenarioResourceType["List"] = "List";
+    ExampleScenarioResourceType["Questionnaire"] = "Questionnaire";
+    ExampleScenarioResourceType["DomainResource"] = "DomainResource";
+    ExampleScenarioResourceType["Endpoint"] = "Endpoint";
+    ExampleScenarioResourceType["NamingSystem"] = "NamingSystem";
+    ExampleScenarioResourceType["MedicinalProductPackaged"] = "MedicinalProductPackaged";
+    ExampleScenarioResourceType["Basic"] = "Basic";
+    ExampleScenarioResourceType["Binary"] = "Binary";
+    ExampleScenarioResourceType["PlanDefinition"] = "PlanDefinition";
+    ExampleScenarioResourceType["Subscription"] = "Subscription";
+    ExampleScenarioResourceType["RelatedPerson"] = "RelatedPerson";
+    ExampleScenarioResourceType["SubstanceSpecification"] = "SubstanceSpecification";
+    ExampleScenarioResourceType["SubstanceNucleicAcid"] = "SubstanceNucleicAcid";
+    ExampleScenarioResourceType["GuidanceResponse"] = "GuidanceResponse";
+    ExampleScenarioResourceType["ClinicalImpression"] = "ClinicalImpression";
+    ExampleScenarioResourceType["OrganizationAffiliation"] = "OrganizationAffiliation";
+    ExampleScenarioResourceType["Resource"] = "Resource";
+    ExampleScenarioResourceType["Condition"] = "Condition";
+    ExampleScenarioResourceType["CapabilityStatement"] = "CapabilityStatement";
+    ExampleScenarioResourceType["HealthcareService"] = "HealthcareService";
+    ExampleScenarioResourceType["SpecimenDefinition"] = "SpecimenDefinition";
+    ExampleScenarioResourceType["RiskAssessment"] = "RiskAssessment";
+    ExampleScenarioResourceType["OperationDefinition"] = "OperationDefinition";
+    ExampleScenarioResourceType["ActivityDefinition"] = "ActivityDefinition";
+    ExampleScenarioResourceType["Schedule"] = "Schedule";
+    ExampleScenarioResourceType["BiologicallyDerivedProduct"] = "BiologicallyDerivedProduct";
+    ExampleScenarioResourceType["Group"] = "Group";
+    ExampleScenarioResourceType["MedicinalProductPharmaceutical"] = "MedicinalProductPharmaceutical";
+    ExampleScenarioResourceType["FamilyMemberHistory"] = "FamilyMemberHistory";
+    ExampleScenarioResourceType["ServiceRequest"] = "ServiceRequest";
+    ExampleScenarioResourceType["DetectedIssue"] = "DetectedIssue";
+    ExampleScenarioResourceType["Device"] = "Device";
+    ExampleScenarioResourceType["RequestGroup"] = "RequestGroup";
+    ExampleScenarioResourceType["TestScript"] = "TestScript";
+    ExampleScenarioResourceType["RiskEvidenceSynthesis"] = "RiskEvidenceSynthesis";
+    ExampleScenarioResourceType["SupplyRequest"] = "SupplyRequest";
+    ExampleScenarioResourceType["Task"] = "Task";
+    ExampleScenarioResourceType["CommunicationRequest"] = "CommunicationRequest";
+    ExampleScenarioResourceType["EnrollmentRequest"] = "EnrollmentRequest";
+    ExampleScenarioResourceType["ChargeItemDefinition"] = "ChargeItemDefinition";
+    ExampleScenarioResourceType["Substance"] = "Substance";
+    ExampleScenarioResourceType["Provenance"] = "Provenance";
+    ExampleScenarioResourceType["Consent"] = "Consent";
+    ExampleScenarioResourceType["CarePlan"] = "CarePlan";
+    ExampleScenarioResourceType["TestReport"] = "TestReport";
+    ExampleScenarioResourceType["Observation"] = "Observation";
+    ExampleScenarioResourceType["DocumentManifest"] = "DocumentManifest";
+})(ExampleScenarioResourceType = exports.ExampleScenarioResourceType || (exports.ExampleScenarioResourceType = {}));
+/** draft | active | retired | unknown */
+var ExampleScenarioStatus;
+(function (ExampleScenarioStatus) {
+    ExampleScenarioStatus["Active"] = "active";
+    ExampleScenarioStatus["Draft"] = "draft";
+    ExampleScenarioStatus["Retired"] = "retired";
+    ExampleScenarioStatus["Unknown"] = "unknown";
+})(ExampleScenarioStatus = exports.ExampleScenarioStatus || (exports.ExampleScenarioStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ExplanationOfBenefit.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ExplanationOfBenefit.d.ts
index 885c844..55b3539 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ExplanationOfBenefit.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ExplanationOfBenefit.d.ts
@@ -15,23 +15,23 @@ import { Money } from "./Money";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided. */
 export interface ExplanationOfBenefit extends DomainResource {
+    resourceType: 'ExplanationOfBenefit';
     _created?: Element;
     /** The recipient of the products and services */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** Claim response reference */
-    claimResponse?: Reference<"ClaimResponse">;
+    claimResponse?: Reference<'ClaimResponse'>;
     /** Patient insurance information */
     insurance: Array<ExplanationOfBenefitInsurance>;
     /** Balance by Benefit Category */
     benefitBalance?: Array<ExplanationOfBenefitBenefitBalance>;
     /** Servicing Facility */
-    facility?: Reference<"Location">;
+    facility?: Reference<'Location'>;
     /** Note concerning adjudication */
     processNote?: Array<ExplanationOfBenefitProcessNote>;
     /** Pertinent diagnosis information */
@@ -42,12 +42,12 @@ export interface ExplanationOfBenefit extends DomainResource {
     adjudication?: Array<ExplanationOfBenefitItemAdjudication>;
     _disposition?: Element;
     /** Author of the claim */
-    enterer?: Reference<"PractitionerRole" | "Practitioner">;
+    enterer?: Reference<'PractitionerRole' | 'Practitioner'>;
     /** Supporting information */
     supportingInfo?: Array<ExplanationOfBenefitSupportingInfo>;
     _precedence?: Element;
     /** claim | preauthorization | predetermination */
-    use: code;
+    use: `${ExplanationOfBenefitUse}`;
     /** Payment Details */
     payment?: ExplanationOfBenefitPayment;
     /** Product or service provided */
@@ -60,20 +60,20 @@ export interface ExplanationOfBenefit extends DomainResource {
     /** Clinical procedures performed */
     procedure?: Array<ExplanationOfBenefitProcedure>;
     /** queued | complete | error | partial */
-    outcome: code;
+    outcome: `${ExplanationOfBenefitOutcome}`;
     /** Prior or corollary claims */
     related?: Array<ExplanationOfBenefitRelated>;
     _outcome?: Element;
     /** Disposition Message */
     disposition?: string;
     /** Treatment Referral */
-    referral?: Reference<"ServiceRequest">;
+    referral?: Reference<'ServiceRequest'>;
     /** Preauthorization in-effect period */
     preAuthRefPeriod?: Array<Period>;
     /** Adjudication totals */
     total?: Array<ExplanationOfBenefitTotal>;
     /** Party responsible for reimbursement */
-    insurer: Reference<"Organization">;
+    insurer: Reference<'Organization'>;
     /** Funds reserved status */
     fundsReserve?: CodeableConcept;
     /** Desired processing urgency */
@@ -81,11 +81,11 @@ export interface ExplanationOfBenefit extends DomainResource {
     /** Details of the event */
     accident?: ExplanationOfBenefitAccident;
     /** active | cancelled | draft | entered-in-error */
-    status: code;
+    status: `${ExplanationOfBenefitStatus}`;
     /** Recipient of benefits payable */
     payee?: ExplanationOfBenefitPayee;
     /** Prescription authorizing services or products */
-    prescription?: Reference<"VisionPrescription" | "MedicationRequest">;
+    prescription?: Reference<'VisionPrescription' | 'MedicationRequest'>;
     /** Relevant time frame for the claim */
     billablePeriod?: Period;
     /** Business Identifier for the resource */
@@ -104,16 +104,16 @@ export interface ExplanationOfBenefit extends DomainResource {
     /** Printed form identifier */
     formCode?: CodeableConcept;
     /** Party responsible for the claim */
-    provider: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    provider: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Insurer added line items */
     addItem?: Array<ExplanationOfBenefitAddItem>;
     /** Original prescription if superceded by fulfiller */
-    originalPrescription?: Reference<"MedicationRequest">;
+    originalPrescription?: Reference<'MedicationRequest'>;
     _use?: Element;
     /** Care Team members */
     careTeam?: Array<ExplanationOfBenefitCareTeam>;
     /** Claim reference */
-    claim?: Reference<"Claim">;
+    claim?: Reference<'Claim'>;
 }
 /** Insurer added line items */
 export interface ExplanationOfBenefitAddItem extends BackboneElement {
@@ -135,7 +135,7 @@ export interface ExplanationOfBenefitAddItem extends BackboneElement {
     subSite?: Array<CodeableConcept>;
     /** Billing, service, product, or drug code */
     productOrService: CodeableConcept;
-    locationReference?: Reference<"Location">;
+    locationReference?: Reference<'Location'>;
     _detailSequence?: Array<Element>;
     _itemSequence?: Array<Element>;
     /** Program the product or service is provided under */
@@ -164,7 +164,7 @@ export interface ExplanationOfBenefitAddItem extends BackboneElement {
 /** Prior or corollary claims */
 export interface ExplanationOfBenefitRelated extends BackboneElement {
     /** Reference to the related claim */
-    claim?: Reference<"Claim">;
+    claim?: Reference<'Claim'>;
     /** How the reference claim is related */
     relationship?: CodeableConcept;
     /** File or case reference */
@@ -176,7 +176,7 @@ export interface ExplanationOfBenefitDiagnosis extends BackboneElement {
     sequence: positiveInt;
     _sequence?: Element;
     diagnosisCodeableConcept: CodeableConcept;
-    diagnosisReference: Reference<"Condition">;
+    diagnosisReference: Reference<'Condition'>;
     /** Timing or nature of the diagnosis */
     type?: Array<CodeableConcept>;
     /** Present on admission */
@@ -190,7 +190,7 @@ export interface ExplanationOfBenefitCareTeam extends BackboneElement {
     sequence: positiveInt;
     _sequence?: Element;
     /** Practitioner or organization */
-    provider: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    provider: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Indicator of the lead practitioner */
     responsible?: boolean;
     _responsible?: Element;
@@ -205,11 +205,25 @@ export interface ExplanationOfBenefitInsurance extends BackboneElement {
     focal: boolean;
     _focal?: Element;
     /** Insurance information */
-    coverage: Reference<"Coverage">;
+    coverage: Reference<'Coverage'>;
     /** Prior authorization reference number */
     preAuthRef?: Array<string>;
     _preAuthRef?: Array<Element>;
 }
+/** queued | complete | error | partial */
+export declare enum ExplanationOfBenefitOutcome {
+    Complete = "complete",
+    Error = "error",
+    Partial = "partial",
+    Queued = "queued"
+}
+/** active | cancelled | draft | entered-in-error */
+export declare enum ExplanationOfBenefitStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    EnteredInError = "entered-in-error"
+}
 /** Balance by Benefit Category */
 export interface ExplanationOfBenefitBenefitBalance extends BackboneElement {
     /** Description of the benefit or services covered */
@@ -245,6 +259,12 @@ export interface ExplanationOfBenefitFinancial extends BackboneElement {
     allowedString?: string;
     usedMoney?: Money;
 }
+/** display | print | printoper */
+export declare enum ExplanationOfBenefitType {
+    Display = "display",
+    Print = "print",
+    Printoper = "printoper"
+}
 /** Adjudication details */
 export interface ExplanationOfBenefitItemAdjudication extends BackboneElement {
     /** Type of adjudication information */
@@ -263,7 +283,7 @@ export interface ExplanationOfBenefitProcessNote extends BackboneElement {
     number?: positiveInt;
     _number?: Element;
     /** display | print | printoper */
-    type?: code;
+    type?: `${ExplanationOfBenefitType}`;
     _type?: Element;
     /** Note explanatory text */
     text?: string;
@@ -302,7 +322,7 @@ export interface ExplanationOfBenefitItem extends BackboneElement {
     /** Billing, service, product, or drug code */
     productOrService: CodeableConcept;
     _informationSequence?: Array<Element>;
-    locationReference?: Reference<"Location">;
+    locationReference?: Reference<'Location'>;
     /** Unique device identifier */
     udi?: Array<Reference>;
     /** Applicable exception and supporting information */
@@ -336,7 +356,7 @@ export interface ExplanationOfBenefitAccident extends BackboneElement {
     /** The nature of the accident */
     type?: CodeableConcept;
     locationAddress?: Address;
-    locationReference?: Reference<"Location">;
+    locationReference?: Reference<'Location'>;
 }
 /** Additional items */
 export interface ExplanationOfBenefitDetail extends BackboneElement {
@@ -417,7 +437,7 @@ export interface ExplanationOfBenefitProcedure extends BackboneElement {
     /** When the procedure was performed */
     date?: dateTime;
     procedureCodeableConcept: CodeableConcept;
-    procedureReference: Reference<"Procedure">;
+    procedureReference: Reference<'Procedure'>;
     _date?: Element;
     /** Category of Procedure */
     type?: Array<CodeableConcept>;
@@ -431,7 +451,7 @@ export interface ExplanationOfBenefitPayee extends BackboneElement {
     /** Category of recipient */
     type?: CodeableConcept;
     /** Recipient reference */
-    party?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Practitioner" | "RelatedPerson">;
+    party?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Practitioner' | 'RelatedPerson'>;
 }
 /** Supporting information */
 export interface ExplanationOfBenefitSupportingInfo extends BackboneElement {
@@ -455,6 +475,12 @@ export interface ExplanationOfBenefitSupportingInfo extends BackboneElement {
     valueAttachment?: Attachment;
     _timingDate?: Element;
 }
+/** claim | preauthorization | predetermination */
+export declare enum ExplanationOfBenefitUse {
+    Claim = "claim",
+    Preauthorization = "preauthorization",
+    Predetermination = "predetermination"
+}
 /** Payment Details */
 export interface ExplanationOfBenefitPayment extends BackboneElement {
     /** Partial or complete payment */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ExplanationOfBenefit.js b/vendor/r4/types/hl7-fhir-r4-core/ExplanationOfBenefit.js
index c8ad2e5..a44be9b 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ExplanationOfBenefit.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ExplanationOfBenefit.js
@@ -1,2 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplanationOfBenefitUse = exports.ExplanationOfBenefitType = exports.ExplanationOfBenefitStatus = exports.ExplanationOfBenefitOutcome = void 0;
+/** queued | complete | error | partial */
+var ExplanationOfBenefitOutcome;
+(function (ExplanationOfBenefitOutcome) {
+    ExplanationOfBenefitOutcome["Complete"] = "complete";
+    ExplanationOfBenefitOutcome["Error"] = "error";
+    ExplanationOfBenefitOutcome["Partial"] = "partial";
+    ExplanationOfBenefitOutcome["Queued"] = "queued";
+})(ExplanationOfBenefitOutcome = exports.ExplanationOfBenefitOutcome || (exports.ExplanationOfBenefitOutcome = {}));
+/** active | cancelled | draft | entered-in-error */
+var ExplanationOfBenefitStatus;
+(function (ExplanationOfBenefitStatus) {
+    ExplanationOfBenefitStatus["Active"] = "active";
+    ExplanationOfBenefitStatus["Cancelled"] = "cancelled";
+    ExplanationOfBenefitStatus["Draft"] = "draft";
+    ExplanationOfBenefitStatus["EnteredInError"] = "entered-in-error";
+})(ExplanationOfBenefitStatus = exports.ExplanationOfBenefitStatus || (exports.ExplanationOfBenefitStatus = {}));
+/** display | print | printoper */
+var ExplanationOfBenefitType;
+(function (ExplanationOfBenefitType) {
+    ExplanationOfBenefitType["Display"] = "display";
+    ExplanationOfBenefitType["Print"] = "print";
+    ExplanationOfBenefitType["Printoper"] = "printoper";
+})(ExplanationOfBenefitType = exports.ExplanationOfBenefitType || (exports.ExplanationOfBenefitType = {}));
+/** claim | preauthorization | predetermination */
+var ExplanationOfBenefitUse;
+(function (ExplanationOfBenefitUse) {
+    ExplanationOfBenefitUse["Claim"] = "claim";
+    ExplanationOfBenefitUse["Preauthorization"] = "preauthorization";
+    ExplanationOfBenefitUse["Predetermination"] = "predetermination";
+})(ExplanationOfBenefitUse = exports.ExplanationOfBenefitUse || (exports.ExplanationOfBenefitUse = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/FamilyMemberHistory.d.ts b/vendor/r4/types/hl7-fhir-r4-core/FamilyMemberHistory.d.ts
index adc1164..32fb882 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/FamilyMemberHistory.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/FamilyMemberHistory.d.ts
@@ -12,15 +12,15 @@ import { DomainResource } from "./DomainResource";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Significant health conditions for a person related to the patient relevant in the context of care for the patient. */
 export interface FamilyMemberHistory extends DomainResource {
+    resourceType: 'FamilyMemberHistory';
     deceasedAge?: Age;
     _bornDate?: Element;
     /** Patient history is about */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     _deceasedDate?: Element;
     /** When history was recorded or last updated */
     date?: dateTime;
@@ -49,7 +49,7 @@ export interface FamilyMemberHistory extends DomainResource {
     note?: Array<Annotation>;
     _ageString?: Element;
     /** partial | completed | entered-in-error | health-unknown */
-    status: code;
+    status: `${FamilyMemberHistoryStatus}`;
     /** Condition that the related person had */
     condition?: Array<FamilyMemberHistoryCondition>;
     _name?: Element;
@@ -71,6 +71,13 @@ export interface FamilyMemberHistory extends DomainResource {
     /** Age is estimated? */
     estimatedAge?: boolean;
 }
+/** partial | completed | entered-in-error | health-unknown */
+export declare enum FamilyMemberHistoryStatus {
+    Completed = "completed",
+    EnteredInError = "entered-in-error",
+    HealthUnknown = "health-unknown",
+    Partial = "partial"
+}
 /** Condition that the related person had */
 export interface FamilyMemberHistoryCondition extends BackboneElement {
     _onsetString?: Element;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/FamilyMemberHistory.js b/vendor/r4/types/hl7-fhir-r4-core/FamilyMemberHistory.js
index c8ad2e5..cc93019 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/FamilyMemberHistory.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/FamilyMemberHistory.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FamilyMemberHistoryStatus = void 0;
+/** partial | completed | entered-in-error | health-unknown */
+var FamilyMemberHistoryStatus;
+(function (FamilyMemberHistoryStatus) {
+    FamilyMemberHistoryStatus["Completed"] = "completed";
+    FamilyMemberHistoryStatus["EnteredInError"] = "entered-in-error";
+    FamilyMemberHistoryStatus["HealthUnknown"] = "health-unknown";
+    FamilyMemberHistoryStatus["Partial"] = "partial";
+})(FamilyMemberHistoryStatus = exports.FamilyMemberHistoryStatus || (exports.FamilyMemberHistoryStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Flag.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Flag.d.ts
index a9eb2a6..6c26530 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Flag.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Flag.d.ts
@@ -5,19 +5,19 @@ import { CodeableConcept } from "./CodeableConcept";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** Prospective warnings of potential issues when providing care to the patient. */
 export interface Flag extends DomainResource {
+    resourceType: 'Flag';
     /** Clinical, administrative, etc. */
     category?: Array<CodeableConcept>;
     /** Alert relevant during encounter */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _status?: Element;
     /** Flag creator */
-    author?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner">;
+    author?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner'>;
     /** active | inactive | entered-in-error */
-    status: code;
+    status: `${FlagStatus}`;
     /** Coded or textual message to display to user */
     code: CodeableConcept;
     /** Business identifier */
@@ -25,5 +25,11 @@ export interface Flag extends DomainResource {
     /** Time period when flag is active */
     period?: Period;
     /** Who/What is flag about? */
-    subject: Reference<"Patient" | "Medication" | "Organization" | "Location" | "Practitioner" | "PlanDefinition" | "Procedure" | "Group">;
+    subject: Reference<'Patient' | 'Medication' | 'Organization' | 'Location' | 'Practitioner' | 'PlanDefinition' | 'Procedure' | 'Group'>;
+}
+/** active | inactive | entered-in-error */
+export declare enum FlagStatus {
+    Active = "active",
+    EnteredInError = "entered-in-error",
+    Inactive = "inactive"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Flag.js b/vendor/r4/types/hl7-fhir-r4-core/Flag.js
index c8ad2e5..d3e4da3 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Flag.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Flag.js
@@ -1,2 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlagStatus = void 0;
+/** active | inactive | entered-in-error */
+var FlagStatus;
+(function (FlagStatus) {
+    FlagStatus["Active"] = "active";
+    FlagStatus["EnteredInError"] = "entered-in-error";
+    FlagStatus["Inactive"] = "inactive";
+})(FlagStatus = exports.FlagStatus || (exports.FlagStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Goal.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Goal.d.ts
index 703d3f3..dae6d9a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Goal.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Goal.d.ts
@@ -11,11 +11,11 @@ import { date } from "./date";
 import { Ratio } from "./Ratio";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Describes the intended objective(s) for a patient, group or organization care, for example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc. */
 export interface Goal extends DomainResource {
+    resourceType: 'Goal';
     /** Code or text describing goal */
     description: CodeableConcept;
     /** E.g. Treatment, dietary, behavioral, etc. */
@@ -23,7 +23,7 @@ export interface Goal extends DomainResource {
     /** Issues addressed by this goal */
     addresses?: Array<Reference>;
     /** Who's responsible for creating Goal? */
-    expressedBy?: Reference<"Patient" | "PractitionerRole" | "Practitioner" | "RelatedPerson">;
+    expressedBy?: Reference<'Patient' | 'PractitionerRole' | 'Practitioner' | 'RelatedPerson'>;
     startDate?: date;
     /** in-progress | improving | worsening | no-change | achieved | sustaining | not-achieved | no-progress | not-attainable */
     achievementStatus?: CodeableConcept;
@@ -47,10 +47,10 @@ export interface Goal extends DomainResource {
     /** Observation that resulted from goal */
     outcomeReference?: Array<Reference>;
     /** Who this goal is intended for */
-    subject: Reference<"Patient" | "Organization" | "Group">;
+    subject: Reference<'Patient' | 'Organization' | 'Group'>;
     _statusReason?: Element;
     /** proposed | planned | accepted | active | on-hold | completed | cancelled | entered-in-error | rejected */
-    lifecycleStatus: code;
+    lifecycleStatus: `${GoalLifecycleStatus}`;
     _statusDate?: Element;
 }
 /** Target outcome for the goal */
@@ -71,3 +71,15 @@ export interface GoalTarget extends BackboneElement {
     _dueDate?: Element;
     dueDuration?: Duration;
 }
+/** proposed | planned | accepted | active | on-hold | completed | cancelled | entered-in-error | rejected */
+export declare enum GoalLifecycleStatus {
+    Active = "active",
+    Proposed = "proposed",
+    Cancelled = "cancelled",
+    Rejected = "rejected",
+    Planned = "planned",
+    EnteredInError = "entered-in-error",
+    Completed = "completed",
+    Accepted = "accepted",
+    OnHold = "on-hold"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Goal.js b/vendor/r4/types/hl7-fhir-r4-core/Goal.js
index c8ad2e5..c8e9c68 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Goal.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Goal.js
@@ -1,2 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoalLifecycleStatus = void 0;
+/** proposed | planned | accepted | active | on-hold | completed | cancelled | entered-in-error | rejected */
+var GoalLifecycleStatus;
+(function (GoalLifecycleStatus) {
+    GoalLifecycleStatus["Active"] = "active";
+    GoalLifecycleStatus["Proposed"] = "proposed";
+    GoalLifecycleStatus["Cancelled"] = "cancelled";
+    GoalLifecycleStatus["Rejected"] = "rejected";
+    GoalLifecycleStatus["Planned"] = "planned";
+    GoalLifecycleStatus["EnteredInError"] = "entered-in-error";
+    GoalLifecycleStatus["Completed"] = "completed";
+    GoalLifecycleStatus["Accepted"] = "accepted";
+    GoalLifecycleStatus["OnHold"] = "on-hold";
+})(GoalLifecycleStatus = exports.GoalLifecycleStatus || (exports.GoalLifecycleStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/GraphDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/GraphDefinition.d.ts
index 3954c42..f3e6fc9 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/GraphDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/GraphDefinition.d.ts
@@ -10,10 +10,10 @@ import { integer } from "./integer";
 import { DomainResource } from "./DomainResource";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
-import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** A formal computable definition of a graph of resources - that is, a coherent set of resources that form a graph by following references. The Graph Definition resource defines a set and makes rules about the set. */
 export interface GraphDefinition extends DomainResource {
+    resourceType: 'GraphDefinition';
     /** Natural language description of the graph definition */
     description?: markdown;
     /** Date last changed */
@@ -30,7 +30,7 @@ export interface GraphDefinition extends DomainResource {
     name: string;
     _status?: Element;
     /** Type of resource at which the graph starts */
-    start: code;
+    start: `${GraphDefinitionStart}`;
     _experimental?: Element;
     /** The context that the content is intended to support */
     useContext?: Array<UsageContext>;
@@ -40,7 +40,7 @@ export interface GraphDefinition extends DomainResource {
     _profile?: Element;
     _purpose?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${GraphDefinitionStatus}`;
     link?: Array<GraphDefinitionLink>;
     _name?: Element;
     /** Canonical identifier for this graph definition, represented as a URI (globally unique) */
@@ -55,6 +55,26 @@ export interface GraphDefinition extends DomainResource {
     /** Profile on base resource */
     profile?: canonical;
 }
+/** Links this graph makes rules about */
+export interface GraphDefinitionLink extends BackboneElement {
+    /** Why this link is specified */
+    description?: string;
+    /** Path in the resource that contains the link */
+    path?: string;
+    /** Minimum occurrences for this link */
+    min?: integer;
+    _path?: Element;
+    _sliceName?: Element;
+    /** Which slice (if profiled) */
+    sliceName?: string;
+    _description?: Element;
+    _min?: Element;
+    /** Maximum occurrences for this link */
+    max?: string;
+    _max?: Element;
+    /** Potential target for the link */
+    target?: Array<GraphDefinitionLinkTarget>;
+}
 /** Compartment Consistency Rules */
 export interface GraphDefinitionLinkCompartment extends BackboneElement {
     /** Documentation for FHIRPath expression */
@@ -63,20 +83,32 @@ export interface GraphDefinitionLinkCompartment extends BackboneElement {
     /** Custom rule, as a FHIRPath expression */
     expression?: string;
     /** condition | requirement */
-    use: code;
+    use: `${GraphDefinitionLinkUse}`;
     /** identical | matching | different | custom */
-    rule: code;
+    rule: `${GraphDefinitionLinkRule}`;
     _expression?: Element;
     _description?: Element;
     /** Patient | Encounter | RelatedPerson | Practitioner | Device */
-    code: code;
+    code: `${GraphDefinitionLinkCode}`;
     _rule?: Element;
     _use?: Element;
 }
+/** draft | active | retired | unknown */
+export declare enum GraphDefinitionStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** condition | requirement */
+export declare enum GraphDefinitionLinkUse {
+    Condition = "condition",
+    Requirement = "requirement"
+}
 /** Potential target for the link */
 export interface GraphDefinitionLinkTarget extends BackboneElement {
     /** Type of resource this link refers to */
-    type: code;
+    type: `${GraphDefinitionLinkType}`;
     _type?: Element;
     /** Criteria for reverse lookup */
     params?: string;
@@ -89,23 +121,320 @@ export interface GraphDefinitionLinkTarget extends BackboneElement {
     /** Additional links from target resource */
     link?: Array<GraphDefinitionLink>;
 }
-/** Links this graph makes rules about */
-export interface GraphDefinitionLink extends BackboneElement {
-    /** Why this link is specified */
-    description?: string;
-    /** Path in the resource that contains the link */
-    path?: string;
-    /** Minimum occurrences for this link */
-    min?: integer;
-    _path?: Element;
-    _sliceName?: Element;
-    /** Which slice (if profiled) */
-    sliceName?: string;
-    _description?: Element;
-    _min?: Element;
-    /** Maximum occurrences for this link */
-    max?: string;
-    _max?: Element;
-    /** Potential target for the link */
-    target?: Array<GraphDefinitionLinkTarget>;
+/** identical | matching | different | custom */
+export declare enum GraphDefinitionLinkRule {
+    Custom = "custom",
+    Different = "different",
+    Identical = "identical",
+    Matching = "matching"
+}
+/** Type of resource at which the graph starts */
+export declare enum GraphDefinitionStart {
+    ImmunizationEvaluation = "ImmunizationEvaluation",
+    Appointment = "Appointment",
+    StructureMap = "StructureMap",
+    CareTeam = "CareTeam",
+    Linkage = "Linkage",
+    Communication = "Communication",
+    MedicationDispense = "MedicationDispense",
+    ImagingStudy = "ImagingStudy",
+    ChargeItem = "ChargeItem",
+    AdverseEvent = "AdverseEvent",
+    Media = "Media",
+    SubstancePolymer = "SubstancePolymer",
+    QuestionnaireResponse = "QuestionnaireResponse",
+    Coverage = "Coverage",
+    Procedure = "Procedure",
+    AuditEvent = "AuditEvent",
+    PaymentReconciliation = "PaymentReconciliation",
+    MedicinalProductManufactured = "MedicinalProductManufactured",
+    CompartmentDefinition = "CompartmentDefinition",
+    Organization = "Organization",
+    ExplanationOfBenefit = "ExplanationOfBenefit",
+    Composition = "Composition",
+    CoverageEligibilityResponse = "CoverageEligibilityResponse",
+    DocumentReference = "DocumentReference",
+    EventDefinition = "EventDefinition",
+    SubstanceProtein = "SubstanceProtein",
+    TerminologyCapabilities = "TerminologyCapabilities",
+    Encounter = "Encounter",
+    ImplementationGuide = "ImplementationGuide",
+    EvidenceVariable = "EvidenceVariable",
+    ObservationDefinition = "ObservationDefinition",
+    DiagnosticReport = "DiagnosticReport",
+    ExampleScenario = "ExampleScenario",
+    ResearchDefinition = "ResearchDefinition",
+    Parameters = "Parameters",
+    SearchParameter = "SearchParameter",
+    MedicinalProductInteraction = "MedicinalProductInteraction",
+    CodeSystem = "CodeSystem",
+    MessageDefinition = "MessageDefinition",
+    NutritionOrder = "NutritionOrder",
+    VerificationResult = "VerificationResult",
+    MedicationAdministration = "MedicationAdministration",
+    CatalogEntry = "CatalogEntry",
+    Flag = "Flag",
+    DeviceUseStatement = "DeviceUseStatement",
+    Contract = "Contract",
+    Invoice = "Invoice",
+    PaymentNotice = "PaymentNotice",
+    Location = "Location",
+    Claim = "Claim",
+    Specimen = "Specimen",
+    MedicationStatement = "MedicationStatement",
+    EnrollmentResponse = "EnrollmentResponse",
+    Evidence = "Evidence",
+    Bundle = "Bundle",
+    ResearchElementDefinition = "ResearchElementDefinition",
+    BodyStructure = "BodyStructure",
+    MedicinalProduct = "MedicinalProduct",
+    ResearchStudy = "ResearchStudy",
+    AppointmentResponse = "AppointmentResponse",
+    MedicinalProductIndication = "MedicinalProductIndication",
+    Measure = "Measure",
+    Person = "Person",
+    InsurancePlan = "InsurancePlan",
+    Patient = "Patient",
+    EffectEvidenceSynthesis = "EffectEvidenceSynthesis",
+    ResearchSubject = "ResearchSubject",
+    Medication = "Medication",
+    ConceptMap = "ConceptMap",
+    CoverageEligibilityRequest = "CoverageEligibilityRequest",
+    SubstanceSourceMaterial = "SubstanceSourceMaterial",
+    VisionPrescription = "VisionPrescription",
+    MolecularSequence = "MolecularSequence",
+    MedicinalProductUndesirableEffect = "MedicinalProductUndesirableEffect",
+    OperationOutcome = "OperationOutcome",
+    MessageHeader = "MessageHeader",
+    AllergyIntolerance = "AllergyIntolerance",
+    SubstanceReferenceInformation = "SubstanceReferenceInformation",
+    SupplyDelivery = "SupplyDelivery",
+    EpisodeOfCare = "EpisodeOfCare",
+    PractitionerRole = "PractitionerRole",
+    Library = "Library",
+    Practitioner = "Practitioner",
+    MedicationRequest = "MedicationRequest",
+    ImmunizationRecommendation = "ImmunizationRecommendation",
+    Immunization = "Immunization",
+    GraphDefinition = "GraphDefinition",
+    Account = "Account",
+    MedicinalProductIngredient = "MedicinalProductIngredient",
+    MeasureReport = "MeasureReport",
+    DeviceMetric = "DeviceMetric",
+    Goal = "Goal",
+    MedicationKnowledge = "MedicationKnowledge",
+    ClaimResponse = "ClaimResponse",
+    DeviceDefinition = "DeviceDefinition",
+    Slot = "Slot",
+    ValueSet = "ValueSet",
+    MedicinalProductAuthorization = "MedicinalProductAuthorization",
+    StructureDefinition = "StructureDefinition",
+    MedicinalProductContraindication = "MedicinalProductContraindication",
+    DeviceRequest = "DeviceRequest",
+    List = "List",
+    Questionnaire = "Questionnaire",
+    DomainResource = "DomainResource",
+    Endpoint = "Endpoint",
+    NamingSystem = "NamingSystem",
+    MedicinalProductPackaged = "MedicinalProductPackaged",
+    Basic = "Basic",
+    Binary = "Binary",
+    PlanDefinition = "PlanDefinition",
+    Subscription = "Subscription",
+    RelatedPerson = "RelatedPerson",
+    SubstanceSpecification = "SubstanceSpecification",
+    SubstanceNucleicAcid = "SubstanceNucleicAcid",
+    GuidanceResponse = "GuidanceResponse",
+    ClinicalImpression = "ClinicalImpression",
+    OrganizationAffiliation = "OrganizationAffiliation",
+    Resource = "Resource",
+    Condition = "Condition",
+    CapabilityStatement = "CapabilityStatement",
+    HealthcareService = "HealthcareService",
+    SpecimenDefinition = "SpecimenDefinition",
+    RiskAssessment = "RiskAssessment",
+    OperationDefinition = "OperationDefinition",
+    ActivityDefinition = "ActivityDefinition",
+    Schedule = "Schedule",
+    BiologicallyDerivedProduct = "BiologicallyDerivedProduct",
+    Group = "Group",
+    MedicinalProductPharmaceutical = "MedicinalProductPharmaceutical",
+    FamilyMemberHistory = "FamilyMemberHistory",
+    ServiceRequest = "ServiceRequest",
+    DetectedIssue = "DetectedIssue",
+    Device = "Device",
+    RequestGroup = "RequestGroup",
+    TestScript = "TestScript",
+    RiskEvidenceSynthesis = "RiskEvidenceSynthesis",
+    SupplyRequest = "SupplyRequest",
+    Task = "Task",
+    CommunicationRequest = "CommunicationRequest",
+    EnrollmentRequest = "EnrollmentRequest",
+    ChargeItemDefinition = "ChargeItemDefinition",
+    Substance = "Substance",
+    Provenance = "Provenance",
+    Consent = "Consent",
+    CarePlan = "CarePlan",
+    TestReport = "TestReport",
+    Observation = "Observation",
+    DocumentManifest = "DocumentManifest"
+}
+/** Patient | Encounter | RelatedPerson | Practitioner | Device */
+export declare enum GraphDefinitionLinkCode {
+    Device = "Device",
+    Encounter = "Encounter",
+    Patient = "Patient",
+    Practitioner = "Practitioner",
+    RelatedPerson = "RelatedPerson"
+}
+/** Type of resource this link refers to */
+export declare enum GraphDefinitionLinkType {
+    ImmunizationEvaluation = "ImmunizationEvaluation",
+    Appointment = "Appointment",
+    StructureMap = "StructureMap",
+    CareTeam = "CareTeam",
+    Linkage = "Linkage",
+    Communication = "Communication",
+    MedicationDispense = "MedicationDispense",
+    ImagingStudy = "ImagingStudy",
+    ChargeItem = "ChargeItem",
+    AdverseEvent = "AdverseEvent",
+    Media = "Media",
+    SubstancePolymer = "SubstancePolymer",
+    QuestionnaireResponse = "QuestionnaireResponse",
+    Coverage = "Coverage",
+    Procedure = "Procedure",
+    AuditEvent = "AuditEvent",
+    PaymentReconciliation = "PaymentReconciliation",
+    MedicinalProductManufactured = "MedicinalProductManufactured",
+    CompartmentDefinition = "CompartmentDefinition",
+    Organization = "Organization",
+    ExplanationOfBenefit = "ExplanationOfBenefit",
+    Composition = "Composition",
+    CoverageEligibilityResponse = "CoverageEligibilityResponse",
+    DocumentReference = "DocumentReference",
+    EventDefinition = "EventDefinition",
+    SubstanceProtein = "SubstanceProtein",
+    TerminologyCapabilities = "TerminologyCapabilities",
+    Encounter = "Encounter",
+    ImplementationGuide = "ImplementationGuide",
+    EvidenceVariable = "EvidenceVariable",
+    ObservationDefinition = "ObservationDefinition",
+    DiagnosticReport = "DiagnosticReport",
+    ExampleScenario = "ExampleScenario",
+    ResearchDefinition = "ResearchDefinition",
+    Parameters = "Parameters",
+    SearchParameter = "SearchParameter",
+    MedicinalProductInteraction = "MedicinalProductInteraction",
+    CodeSystem = "CodeSystem",
+    MessageDefinition = "MessageDefinition",
+    NutritionOrder = "NutritionOrder",
+    VerificationResult = "VerificationResult",
+    MedicationAdministration = "MedicationAdministration",
+    CatalogEntry = "CatalogEntry",
+    Flag = "Flag",
+    DeviceUseStatement = "DeviceUseStatement",
+    Contract = "Contract",
+    Invoice = "Invoice",
+    PaymentNotice = "PaymentNotice",
+    Location = "Location",
+    Claim = "Claim",
+    Specimen = "Specimen",
+    MedicationStatement = "MedicationStatement",
+    EnrollmentResponse = "EnrollmentResponse",
+    Evidence = "Evidence",
+    Bundle = "Bundle",
+    ResearchElementDefinition = "ResearchElementDefinition",
+    BodyStructure = "BodyStructure",
+    MedicinalProduct = "MedicinalProduct",
+    ResearchStudy = "ResearchStudy",
+    AppointmentResponse = "AppointmentResponse",
+    MedicinalProductIndication = "MedicinalProductIndication",
+    Measure = "Measure",
+    Person = "Person",
+    InsurancePlan = "InsurancePlan",
+    Patient = "Patient",
+    EffectEvidenceSynthesis = "EffectEvidenceSynthesis",
+    ResearchSubject = "ResearchSubject",
+    Medication = "Medication",
+    ConceptMap = "ConceptMap",
+    CoverageEligibilityRequest = "CoverageEligibilityRequest",
+    SubstanceSourceMaterial = "SubstanceSourceMaterial",
+    VisionPrescription = "VisionPrescription",
+    MolecularSequence = "MolecularSequence",
+    MedicinalProductUndesirableEffect = "MedicinalProductUndesirableEffect",
+    OperationOutcome = "OperationOutcome",
+    MessageHeader = "MessageHeader",
+    AllergyIntolerance = "AllergyIntolerance",
+    SubstanceReferenceInformation = "SubstanceReferenceInformation",
+    SupplyDelivery = "SupplyDelivery",
+    EpisodeOfCare = "EpisodeOfCare",
+    PractitionerRole = "PractitionerRole",
+    Library = "Library",
+    Practitioner = "Practitioner",
+    MedicationRequest = "MedicationRequest",
+    ImmunizationRecommendation = "ImmunizationRecommendation",
+    Immunization = "Immunization",
+    GraphDefinition = "GraphDefinition",
+    Account = "Account",
+    MedicinalProductIngredient = "MedicinalProductIngredient",
+    MeasureReport = "MeasureReport",
+    DeviceMetric = "DeviceMetric",
+    Goal = "Goal",
+    MedicationKnowledge = "MedicationKnowledge",
+    ClaimResponse = "ClaimResponse",
+    DeviceDefinition = "DeviceDefinition",
+    Slot = "Slot",
+    ValueSet = "ValueSet",
+    MedicinalProductAuthorization = "MedicinalProductAuthorization",
+    StructureDefinition = "StructureDefinition",
+    MedicinalProductContraindication = "MedicinalProductContraindication",
+    DeviceRequest = "DeviceRequest",
+    List = "List",
+    Questionnaire = "Questionnaire",
+    DomainResource = "DomainResource",
+    Endpoint = "Endpoint",
+    NamingSystem = "NamingSystem",
+    MedicinalProductPackaged = "MedicinalProductPackaged",
+    Basic = "Basic",
+    Binary = "Binary",
+    PlanDefinition = "PlanDefinition",
+    Subscription = "Subscription",
+    RelatedPerson = "RelatedPerson",
+    SubstanceSpecification = "SubstanceSpecification",
+    SubstanceNucleicAcid = "SubstanceNucleicAcid",
+    GuidanceResponse = "GuidanceResponse",
+    ClinicalImpression = "ClinicalImpression",
+    OrganizationAffiliation = "OrganizationAffiliation",
+    Resource = "Resource",
+    Condition = "Condition",
+    CapabilityStatement = "CapabilityStatement",
+    HealthcareService = "HealthcareService",
+    SpecimenDefinition = "SpecimenDefinition",
+    RiskAssessment = "RiskAssessment",
+    OperationDefinition = "OperationDefinition",
+    ActivityDefinition = "ActivityDefinition",
+    Schedule = "Schedule",
+    BiologicallyDerivedProduct = "BiologicallyDerivedProduct",
+    Group = "Group",
+    MedicinalProductPharmaceutical = "MedicinalProductPharmaceutical",
+    FamilyMemberHistory = "FamilyMemberHistory",
+    ServiceRequest = "ServiceRequest",
+    DetectedIssue = "DetectedIssue",
+    Device = "Device",
+    RequestGroup = "RequestGroup",
+    TestScript = "TestScript",
+    RiskEvidenceSynthesis = "RiskEvidenceSynthesis",
+    SupplyRequest = "SupplyRequest",
+    Task = "Task",
+    CommunicationRequest = "CommunicationRequest",
+    EnrollmentRequest = "EnrollmentRequest",
+    ChargeItemDefinition = "ChargeItemDefinition",
+    Substance = "Substance",
+    Provenance = "Provenance",
+    Consent = "Consent",
+    CarePlan = "CarePlan",
+    TestReport = "TestReport",
+    Observation = "Observation",
+    DocumentManifest = "DocumentManifest"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/GraphDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/GraphDefinition.js
index c8ad2e5..e6b296d 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/GraphDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/GraphDefinition.js
@@ -1,2 +1,338 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphDefinitionLinkType = exports.GraphDefinitionLinkCode = exports.GraphDefinitionStart = exports.GraphDefinitionLinkRule = exports.GraphDefinitionLinkUse = exports.GraphDefinitionStatus = void 0;
+/** draft | active | retired | unknown */
+var GraphDefinitionStatus;
+(function (GraphDefinitionStatus) {
+    GraphDefinitionStatus["Active"] = "active";
+    GraphDefinitionStatus["Draft"] = "draft";
+    GraphDefinitionStatus["Retired"] = "retired";
+    GraphDefinitionStatus["Unknown"] = "unknown";
+})(GraphDefinitionStatus = exports.GraphDefinitionStatus || (exports.GraphDefinitionStatus = {}));
+/** condition | requirement */
+var GraphDefinitionLinkUse;
+(function (GraphDefinitionLinkUse) {
+    GraphDefinitionLinkUse["Condition"] = "condition";
+    GraphDefinitionLinkUse["Requirement"] = "requirement";
+})(GraphDefinitionLinkUse = exports.GraphDefinitionLinkUse || (exports.GraphDefinitionLinkUse = {}));
+/** identical | matching | different | custom */
+var GraphDefinitionLinkRule;
+(function (GraphDefinitionLinkRule) {
+    GraphDefinitionLinkRule["Custom"] = "custom";
+    GraphDefinitionLinkRule["Different"] = "different";
+    GraphDefinitionLinkRule["Identical"] = "identical";
+    GraphDefinitionLinkRule["Matching"] = "matching";
+})(GraphDefinitionLinkRule = exports.GraphDefinitionLinkRule || (exports.GraphDefinitionLinkRule = {}));
+/** Type of resource at which the graph starts */
+var GraphDefinitionStart;
+(function (GraphDefinitionStart) {
+    GraphDefinitionStart["ImmunizationEvaluation"] = "ImmunizationEvaluation";
+    GraphDefinitionStart["Appointment"] = "Appointment";
+    GraphDefinitionStart["StructureMap"] = "StructureMap";
+    GraphDefinitionStart["CareTeam"] = "CareTeam";
+    GraphDefinitionStart["Linkage"] = "Linkage";
+    GraphDefinitionStart["Communication"] = "Communication";
+    GraphDefinitionStart["MedicationDispense"] = "MedicationDispense";
+    GraphDefinitionStart["ImagingStudy"] = "ImagingStudy";
+    GraphDefinitionStart["ChargeItem"] = "ChargeItem";
+    GraphDefinitionStart["AdverseEvent"] = "AdverseEvent";
+    GraphDefinitionStart["Media"] = "Media";
+    GraphDefinitionStart["SubstancePolymer"] = "SubstancePolymer";
+    GraphDefinitionStart["QuestionnaireResponse"] = "QuestionnaireResponse";
+    GraphDefinitionStart["Coverage"] = "Coverage";
+    GraphDefinitionStart["Procedure"] = "Procedure";
+    GraphDefinitionStart["AuditEvent"] = "AuditEvent";
+    GraphDefinitionStart["PaymentReconciliation"] = "PaymentReconciliation";
+    GraphDefinitionStart["MedicinalProductManufactured"] = "MedicinalProductManufactured";
+    GraphDefinitionStart["CompartmentDefinition"] = "CompartmentDefinition";
+    GraphDefinitionStart["Organization"] = "Organization";
+    GraphDefinitionStart["ExplanationOfBenefit"] = "ExplanationOfBenefit";
+    GraphDefinitionStart["Composition"] = "Composition";
+    GraphDefinitionStart["CoverageEligibilityResponse"] = "CoverageEligibilityResponse";
+    GraphDefinitionStart["DocumentReference"] = "DocumentReference";
+    GraphDefinitionStart["EventDefinition"] = "EventDefinition";
+    GraphDefinitionStart["SubstanceProtein"] = "SubstanceProtein";
+    GraphDefinitionStart["TerminologyCapabilities"] = "TerminologyCapabilities";
+    GraphDefinitionStart["Encounter"] = "Encounter";
+    GraphDefinitionStart["ImplementationGuide"] = "ImplementationGuide";
+    GraphDefinitionStart["EvidenceVariable"] = "EvidenceVariable";
+    GraphDefinitionStart["ObservationDefinition"] = "ObservationDefinition";
+    GraphDefinitionStart["DiagnosticReport"] = "DiagnosticReport";
+    GraphDefinitionStart["ExampleScenario"] = "ExampleScenario";
+    GraphDefinitionStart["ResearchDefinition"] = "ResearchDefinition";
+    GraphDefinitionStart["Parameters"] = "Parameters";
+    GraphDefinitionStart["SearchParameter"] = "SearchParameter";
+    GraphDefinitionStart["MedicinalProductInteraction"] = "MedicinalProductInteraction";
+    GraphDefinitionStart["CodeSystem"] = "CodeSystem";
+    GraphDefinitionStart["MessageDefinition"] = "MessageDefinition";
+    GraphDefinitionStart["NutritionOrder"] = "NutritionOrder";
+    GraphDefinitionStart["VerificationResult"] = "VerificationResult";
+    GraphDefinitionStart["MedicationAdministration"] = "MedicationAdministration";
+    GraphDefinitionStart["CatalogEntry"] = "CatalogEntry";
+    GraphDefinitionStart["Flag"] = "Flag";
+    GraphDefinitionStart["DeviceUseStatement"] = "DeviceUseStatement";
+    GraphDefinitionStart["Contract"] = "Contract";
+    GraphDefinitionStart["Invoice"] = "Invoice";
+    GraphDefinitionStart["PaymentNotice"] = "PaymentNotice";
+    GraphDefinitionStart["Location"] = "Location";
+    GraphDefinitionStart["Claim"] = "Claim";
+    GraphDefinitionStart["Specimen"] = "Specimen";
+    GraphDefinitionStart["MedicationStatement"] = "MedicationStatement";
+    GraphDefinitionStart["EnrollmentResponse"] = "EnrollmentResponse";
+    GraphDefinitionStart["Evidence"] = "Evidence";
+    GraphDefinitionStart["Bundle"] = "Bundle";
+    GraphDefinitionStart["ResearchElementDefinition"] = "ResearchElementDefinition";
+    GraphDefinitionStart["BodyStructure"] = "BodyStructure";
+    GraphDefinitionStart["MedicinalProduct"] = "MedicinalProduct";
+    GraphDefinitionStart["ResearchStudy"] = "ResearchStudy";
+    GraphDefinitionStart["AppointmentResponse"] = "AppointmentResponse";
+    GraphDefinitionStart["MedicinalProductIndication"] = "MedicinalProductIndication";
+    GraphDefinitionStart["Measure"] = "Measure";
+    GraphDefinitionStart["Person"] = "Person";
+    GraphDefinitionStart["InsurancePlan"] = "InsurancePlan";
+    GraphDefinitionStart["Patient"] = "Patient";
+    GraphDefinitionStart["EffectEvidenceSynthesis"] = "EffectEvidenceSynthesis";
+    GraphDefinitionStart["ResearchSubject"] = "ResearchSubject";
+    GraphDefinitionStart["Medication"] = "Medication";
+    GraphDefinitionStart["ConceptMap"] = "ConceptMap";
+    GraphDefinitionStart["CoverageEligibilityRequest"] = "CoverageEligibilityRequest";
+    GraphDefinitionStart["SubstanceSourceMaterial"] = "SubstanceSourceMaterial";
+    GraphDefinitionStart["VisionPrescription"] = "VisionPrescription";
+    GraphDefinitionStart["MolecularSequence"] = "MolecularSequence";
+    GraphDefinitionStart["MedicinalProductUndesirableEffect"] = "MedicinalProductUndesirableEffect";
+    GraphDefinitionStart["OperationOutcome"] = "OperationOutcome";
+    GraphDefinitionStart["MessageHeader"] = "MessageHeader";
+    GraphDefinitionStart["AllergyIntolerance"] = "AllergyIntolerance";
+    GraphDefinitionStart["SubstanceReferenceInformation"] = "SubstanceReferenceInformation";
+    GraphDefinitionStart["SupplyDelivery"] = "SupplyDelivery";
+    GraphDefinitionStart["EpisodeOfCare"] = "EpisodeOfCare";
+    GraphDefinitionStart["PractitionerRole"] = "PractitionerRole";
+    GraphDefinitionStart["Library"] = "Library";
+    GraphDefinitionStart["Practitioner"] = "Practitioner";
+    GraphDefinitionStart["MedicationRequest"] = "MedicationRequest";
+    GraphDefinitionStart["ImmunizationRecommendation"] = "ImmunizationRecommendation";
+    GraphDefinitionStart["Immunization"] = "Immunization";
+    GraphDefinitionStart["GraphDefinition"] = "GraphDefinition";
+    GraphDefinitionStart["Account"] = "Account";
+    GraphDefinitionStart["MedicinalProductIngredient"] = "MedicinalProductIngredient";
+    GraphDefinitionStart["MeasureReport"] = "MeasureReport";
+    GraphDefinitionStart["DeviceMetric"] = "DeviceMetric";
+    GraphDefinitionStart["Goal"] = "Goal";
+    GraphDefinitionStart["MedicationKnowledge"] = "MedicationKnowledge";
+    GraphDefinitionStart["ClaimResponse"] = "ClaimResponse";
+    GraphDefinitionStart["DeviceDefinition"] = "DeviceDefinition";
+    GraphDefinitionStart["Slot"] = "Slot";
+    GraphDefinitionStart["ValueSet"] = "ValueSet";
+    GraphDefinitionStart["MedicinalProductAuthorization"] = "MedicinalProductAuthorization";
+    GraphDefinitionStart["StructureDefinition"] = "StructureDefinition";
+    GraphDefinitionStart["MedicinalProductContraindication"] = "MedicinalProductContraindication";
+    GraphDefinitionStart["DeviceRequest"] = "DeviceRequest";
+    GraphDefinitionStart["List"] = "List";
+    GraphDefinitionStart["Questionnaire"] = "Questionnaire";
+    GraphDefinitionStart["DomainResource"] = "DomainResource";
+    GraphDefinitionStart["Endpoint"] = "Endpoint";
+    GraphDefinitionStart["NamingSystem"] = "NamingSystem";
+    GraphDefinitionStart["MedicinalProductPackaged"] = "MedicinalProductPackaged";
+    GraphDefinitionStart["Basic"] = "Basic";
+    GraphDefinitionStart["Binary"] = "Binary";
+    GraphDefinitionStart["PlanDefinition"] = "PlanDefinition";
+    GraphDefinitionStart["Subscription"] = "Subscription";
+    GraphDefinitionStart["RelatedPerson"] = "RelatedPerson";
+    GraphDefinitionStart["SubstanceSpecification"] = "SubstanceSpecification";
+    GraphDefinitionStart["SubstanceNucleicAcid"] = "SubstanceNucleicAcid";
+    GraphDefinitionStart["GuidanceResponse"] = "GuidanceResponse";
+    GraphDefinitionStart["ClinicalImpression"] = "ClinicalImpression";
+    GraphDefinitionStart["OrganizationAffiliation"] = "OrganizationAffiliation";
+    GraphDefinitionStart["Resource"] = "Resource";
+    GraphDefinitionStart["Condition"] = "Condition";
+    GraphDefinitionStart["CapabilityStatement"] = "CapabilityStatement";
+    GraphDefinitionStart["HealthcareService"] = "HealthcareService";
+    GraphDefinitionStart["SpecimenDefinition"] = "SpecimenDefinition";
+    GraphDefinitionStart["RiskAssessment"] = "RiskAssessment";
+    GraphDefinitionStart["OperationDefinition"] = "OperationDefinition";
+    GraphDefinitionStart["ActivityDefinition"] = "ActivityDefinition";
+    GraphDefinitionStart["Schedule"] = "Schedule";
+    GraphDefinitionStart["BiologicallyDerivedProduct"] = "BiologicallyDerivedProduct";
+    GraphDefinitionStart["Group"] = "Group";
+    GraphDefinitionStart["MedicinalProductPharmaceutical"] = "MedicinalProductPharmaceutical";
+    GraphDefinitionStart["FamilyMemberHistory"] = "FamilyMemberHistory";
+    GraphDefinitionStart["ServiceRequest"] = "ServiceRequest";
+    GraphDefinitionStart["DetectedIssue"] = "DetectedIssue";
+    GraphDefinitionStart["Device"] = "Device";
+    GraphDefinitionStart["RequestGroup"] = "RequestGroup";
+    GraphDefinitionStart["TestScript"] = "TestScript";
+    GraphDefinitionStart["RiskEvidenceSynthesis"] = "RiskEvidenceSynthesis";
+    GraphDefinitionStart["SupplyRequest"] = "SupplyRequest";
+    GraphDefinitionStart["Task"] = "Task";
+    GraphDefinitionStart["CommunicationRequest"] = "CommunicationRequest";
+    GraphDefinitionStart["EnrollmentRequest"] = "EnrollmentRequest";
+    GraphDefinitionStart["ChargeItemDefinition"] = "ChargeItemDefinition";
+    GraphDefinitionStart["Substance"] = "Substance";
+    GraphDefinitionStart["Provenance"] = "Provenance";
+    GraphDefinitionStart["Consent"] = "Consent";
+    GraphDefinitionStart["CarePlan"] = "CarePlan";
+    GraphDefinitionStart["TestReport"] = "TestReport";
+    GraphDefinitionStart["Observation"] = "Observation";
+    GraphDefinitionStart["DocumentManifest"] = "DocumentManifest";
+})(GraphDefinitionStart = exports.GraphDefinitionStart || (exports.GraphDefinitionStart = {}));
+/** Patient | Encounter | RelatedPerson | Practitioner | Device */
+var GraphDefinitionLinkCode;
+(function (GraphDefinitionLinkCode) {
+    GraphDefinitionLinkCode["Device"] = "Device";
+    GraphDefinitionLinkCode["Encounter"] = "Encounter";
+    GraphDefinitionLinkCode["Patient"] = "Patient";
+    GraphDefinitionLinkCode["Practitioner"] = "Practitioner";
+    GraphDefinitionLinkCode["RelatedPerson"] = "RelatedPerson";
+})(GraphDefinitionLinkCode = exports.GraphDefinitionLinkCode || (exports.GraphDefinitionLinkCode = {}));
+/** Type of resource this link refers to */
+var GraphDefinitionLinkType;
+(function (GraphDefinitionLinkType) {
+    GraphDefinitionLinkType["ImmunizationEvaluation"] = "ImmunizationEvaluation";
+    GraphDefinitionLinkType["Appointment"] = "Appointment";
+    GraphDefinitionLinkType["StructureMap"] = "StructureMap";
+    GraphDefinitionLinkType["CareTeam"] = "CareTeam";
+    GraphDefinitionLinkType["Linkage"] = "Linkage";
+    GraphDefinitionLinkType["Communication"] = "Communication";
+    GraphDefinitionLinkType["MedicationDispense"] = "MedicationDispense";
+    GraphDefinitionLinkType["ImagingStudy"] = "ImagingStudy";
+    GraphDefinitionLinkType["ChargeItem"] = "ChargeItem";
+    GraphDefinitionLinkType["AdverseEvent"] = "AdverseEvent";
+    GraphDefinitionLinkType["Media"] = "Media";
+    GraphDefinitionLinkType["SubstancePolymer"] = "SubstancePolymer";
+    GraphDefinitionLinkType["QuestionnaireResponse"] = "QuestionnaireResponse";
+    GraphDefinitionLinkType["Coverage"] = "Coverage";
+    GraphDefinitionLinkType["Procedure"] = "Procedure";
+    GraphDefinitionLinkType["AuditEvent"] = "AuditEvent";
+    GraphDefinitionLinkType["PaymentReconciliation"] = "PaymentReconciliation";
+    GraphDefinitionLinkType["MedicinalProductManufactured"] = "MedicinalProductManufactured";
+    GraphDefinitionLinkType["CompartmentDefinition"] = "CompartmentDefinition";
+    GraphDefinitionLinkType["Organization"] = "Organization";
+    GraphDefinitionLinkType["ExplanationOfBenefit"] = "ExplanationOfBenefit";
+    GraphDefinitionLinkType["Composition"] = "Composition";
+    GraphDefinitionLinkType["CoverageEligibilityResponse"] = "CoverageEligibilityResponse";
+    GraphDefinitionLinkType["DocumentReference"] = "DocumentReference";
+    GraphDefinitionLinkType["EventDefinition"] = "EventDefinition";
+    GraphDefinitionLinkType["SubstanceProtein"] = "SubstanceProtein";
+    GraphDefinitionLinkType["TerminologyCapabilities"] = "TerminologyCapabilities";
+    GraphDefinitionLinkType["Encounter"] = "Encounter";
+    GraphDefinitionLinkType["ImplementationGuide"] = "ImplementationGuide";
+    GraphDefinitionLinkType["EvidenceVariable"] = "EvidenceVariable";
+    GraphDefinitionLinkType["ObservationDefinition"] = "ObservationDefinition";
+    GraphDefinitionLinkType["DiagnosticReport"] = "DiagnosticReport";
+    GraphDefinitionLinkType["ExampleScenario"] = "ExampleScenario";
+    GraphDefinitionLinkType["ResearchDefinition"] = "ResearchDefinition";
+    GraphDefinitionLinkType["Parameters"] = "Parameters";
+    GraphDefinitionLinkType["SearchParameter"] = "SearchParameter";
+    GraphDefinitionLinkType["MedicinalProductInteraction"] = "MedicinalProductInteraction";
+    GraphDefinitionLinkType["CodeSystem"] = "CodeSystem";
+    GraphDefinitionLinkType["MessageDefinition"] = "MessageDefinition";
+    GraphDefinitionLinkType["NutritionOrder"] = "NutritionOrder";
+    GraphDefinitionLinkType["VerificationResult"] = "VerificationResult";
+    GraphDefinitionLinkType["MedicationAdministration"] = "MedicationAdministration";
+    GraphDefinitionLinkType["CatalogEntry"] = "CatalogEntry";
+    GraphDefinitionLinkType["Flag"] = "Flag";
+    GraphDefinitionLinkType["DeviceUseStatement"] = "DeviceUseStatement";
+    GraphDefinitionLinkType["Contract"] = "Contract";
+    GraphDefinitionLinkType["Invoice"] = "Invoice";
+    GraphDefinitionLinkType["PaymentNotice"] = "PaymentNotice";
+    GraphDefinitionLinkType["Location"] = "Location";
+    GraphDefinitionLinkType["Claim"] = "Claim";
+    GraphDefinitionLinkType["Specimen"] = "Specimen";
+    GraphDefinitionLinkType["MedicationStatement"] = "MedicationStatement";
+    GraphDefinitionLinkType["EnrollmentResponse"] = "EnrollmentResponse";
+    GraphDefinitionLinkType["Evidence"] = "Evidence";
+    GraphDefinitionLinkType["Bundle"] = "Bundle";
+    GraphDefinitionLinkType["ResearchElementDefinition"] = "ResearchElementDefinition";
+    GraphDefinitionLinkType["BodyStructure"] = "BodyStructure";
+    GraphDefinitionLinkType["MedicinalProduct"] = "MedicinalProduct";
+    GraphDefinitionLinkType["ResearchStudy"] = "ResearchStudy";
+    GraphDefinitionLinkType["AppointmentResponse"] = "AppointmentResponse";
+    GraphDefinitionLinkType["MedicinalProductIndication"] = "MedicinalProductIndication";
+    GraphDefinitionLinkType["Measure"] = "Measure";
+    GraphDefinitionLinkType["Person"] = "Person";
+    GraphDefinitionLinkType["InsurancePlan"] = "InsurancePlan";
+    GraphDefinitionLinkType["Patient"] = "Patient";
+    GraphDefinitionLinkType["EffectEvidenceSynthesis"] = "EffectEvidenceSynthesis";
+    GraphDefinitionLinkType["ResearchSubject"] = "ResearchSubject";
+    GraphDefinitionLinkType["Medication"] = "Medication";
+    GraphDefinitionLinkType["ConceptMap"] = "ConceptMap";
+    GraphDefinitionLinkType["CoverageEligibilityRequest"] = "CoverageEligibilityRequest";
+    GraphDefinitionLinkType["SubstanceSourceMaterial"] = "SubstanceSourceMaterial";
+    GraphDefinitionLinkType["VisionPrescription"] = "VisionPrescription";
+    GraphDefinitionLinkType["MolecularSequence"] = "MolecularSequence";
+    GraphDefinitionLinkType["MedicinalProductUndesirableEffect"] = "MedicinalProductUndesirableEffect";
+    GraphDefinitionLinkType["OperationOutcome"] = "OperationOutcome";
+    GraphDefinitionLinkType["MessageHeader"] = "MessageHeader";
+    GraphDefinitionLinkType["AllergyIntolerance"] = "AllergyIntolerance";
+    GraphDefinitionLinkType["SubstanceReferenceInformation"] = "SubstanceReferenceInformation";
+    GraphDefinitionLinkType["SupplyDelivery"] = "SupplyDelivery";
+    GraphDefinitionLinkType["EpisodeOfCare"] = "EpisodeOfCare";
+    GraphDefinitionLinkType["PractitionerRole"] = "PractitionerRole";
+    GraphDefinitionLinkType["Library"] = "Library";
+    GraphDefinitionLinkType["Practitioner"] = "Practitioner";
+    GraphDefinitionLinkType["MedicationRequest"] = "MedicationRequest";
+    GraphDefinitionLinkType["ImmunizationRecommendation"] = "ImmunizationRecommendation";
+    GraphDefinitionLinkType["Immunization"] = "Immunization";
+    GraphDefinitionLinkType["GraphDefinition"] = "GraphDefinition";
+    GraphDefinitionLinkType["Account"] = "Account";
+    GraphDefinitionLinkType["MedicinalProductIngredient"] = "MedicinalProductIngredient";
+    GraphDefinitionLinkType["MeasureReport"] = "MeasureReport";
+    GraphDefinitionLinkType["DeviceMetric"] = "DeviceMetric";
+    GraphDefinitionLinkType["Goal"] = "Goal";
+    GraphDefinitionLinkType["MedicationKnowledge"] = "MedicationKnowledge";
+    GraphDefinitionLinkType["ClaimResponse"] = "ClaimResponse";
+    GraphDefinitionLinkType["DeviceDefinition"] = "DeviceDefinition";
+    GraphDefinitionLinkType["Slot"] = "Slot";
+    GraphDefinitionLinkType["ValueSet"] = "ValueSet";
+    GraphDefinitionLinkType["MedicinalProductAuthorization"] = "MedicinalProductAuthorization";
+    GraphDefinitionLinkType["StructureDefinition"] = "StructureDefinition";
+    GraphDefinitionLinkType["MedicinalProductContraindication"] = "MedicinalProductContraindication";
+    GraphDefinitionLinkType["DeviceRequest"] = "DeviceRequest";
+    GraphDefinitionLinkType["List"] = "List";
+    GraphDefinitionLinkType["Questionnaire"] = "Questionnaire";
+    GraphDefinitionLinkType["DomainResource"] = "DomainResource";
+    GraphDefinitionLinkType["Endpoint"] = "Endpoint";
+    GraphDefinitionLinkType["NamingSystem"] = "NamingSystem";
+    GraphDefinitionLinkType["MedicinalProductPackaged"] = "MedicinalProductPackaged";
+    GraphDefinitionLinkType["Basic"] = "Basic";
+    GraphDefinitionLinkType["Binary"] = "Binary";
+    GraphDefinitionLinkType["PlanDefinition"] = "PlanDefinition";
+    GraphDefinitionLinkType["Subscription"] = "Subscription";
+    GraphDefinitionLinkType["RelatedPerson"] = "RelatedPerson";
+    GraphDefinitionLinkType["SubstanceSpecification"] = "SubstanceSpecification";
+    GraphDefinitionLinkType["SubstanceNucleicAcid"] = "SubstanceNucleicAcid";
+    GraphDefinitionLinkType["GuidanceResponse"] = "GuidanceResponse";
+    GraphDefinitionLinkType["ClinicalImpression"] = "ClinicalImpression";
+    GraphDefinitionLinkType["OrganizationAffiliation"] = "OrganizationAffiliation";
+    GraphDefinitionLinkType["Resource"] = "Resource";
+    GraphDefinitionLinkType["Condition"] = "Condition";
+    GraphDefinitionLinkType["CapabilityStatement"] = "CapabilityStatement";
+    GraphDefinitionLinkType["HealthcareService"] = "HealthcareService";
+    GraphDefinitionLinkType["SpecimenDefinition"] = "SpecimenDefinition";
+    GraphDefinitionLinkType["RiskAssessment"] = "RiskAssessment";
+    GraphDefinitionLinkType["OperationDefinition"] = "OperationDefinition";
+    GraphDefinitionLinkType["ActivityDefinition"] = "ActivityDefinition";
+    GraphDefinitionLinkType["Schedule"] = "Schedule";
+    GraphDefinitionLinkType["BiologicallyDerivedProduct"] = "BiologicallyDerivedProduct";
+    GraphDefinitionLinkType["Group"] = "Group";
+    GraphDefinitionLinkType["MedicinalProductPharmaceutical"] = "MedicinalProductPharmaceutical";
+    GraphDefinitionLinkType["FamilyMemberHistory"] = "FamilyMemberHistory";
+    GraphDefinitionLinkType["ServiceRequest"] = "ServiceRequest";
+    GraphDefinitionLinkType["DetectedIssue"] = "DetectedIssue";
+    GraphDefinitionLinkType["Device"] = "Device";
+    GraphDefinitionLinkType["RequestGroup"] = "RequestGroup";
+    GraphDefinitionLinkType["TestScript"] = "TestScript";
+    GraphDefinitionLinkType["RiskEvidenceSynthesis"] = "RiskEvidenceSynthesis";
+    GraphDefinitionLinkType["SupplyRequest"] = "SupplyRequest";
+    GraphDefinitionLinkType["Task"] = "Task";
+    GraphDefinitionLinkType["CommunicationRequest"] = "CommunicationRequest";
+    GraphDefinitionLinkType["EnrollmentRequest"] = "EnrollmentRequest";
+    GraphDefinitionLinkType["ChargeItemDefinition"] = "ChargeItemDefinition";
+    GraphDefinitionLinkType["Substance"] = "Substance";
+    GraphDefinitionLinkType["Provenance"] = "Provenance";
+    GraphDefinitionLinkType["Consent"] = "Consent";
+    GraphDefinitionLinkType["CarePlan"] = "CarePlan";
+    GraphDefinitionLinkType["TestReport"] = "TestReport";
+    GraphDefinitionLinkType["Observation"] = "Observation";
+    GraphDefinitionLinkType["DocumentManifest"] = "DocumentManifest";
+})(GraphDefinitionLinkType = exports.GraphDefinitionLinkType || (exports.GraphDefinitionLinkType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Group.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Group.d.ts
index 8380d35..6c436f2 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Group.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Group.d.ts
@@ -8,18 +8,18 @@ import { Quantity } from "./Quantity";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization. */
 export interface Group extends DomainResource {
+    resourceType: 'Group';
     _active?: Element;
     _quantity?: Element;
     /** Label for Group */
     name?: string;
     _type?: Element;
     /** person | animal | practitioner | device | medication | substance */
-    type: code;
+    type: `${GroupType}`;
     /** Who or what is in group */
     member?: Array<GroupMember>;
     /** Include / Exclude group members by Trait */
@@ -35,14 +35,23 @@ export interface Group extends DomainResource {
     /** Number of members */
     quantity?: unsignedInt;
     /** Entity that is the custodian of the Group's definition */
-    managingEntity?: Reference<"PractitionerRole" | "Organization" | "Practitioner" | "RelatedPerson">;
+    managingEntity?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner' | 'RelatedPerson'>;
     /** Descriptive or actual */
     actual: boolean;
 }
+/** person | animal | practitioner | device | medication | substance */
+export declare enum GroupType {
+    Animal = "animal",
+    Device = "device",
+    Medication = "medication",
+    Person = "person",
+    Practitioner = "practitioner",
+    Substance = "substance"
+}
 /** Who or what is in group */
 export interface GroupMember extends BackboneElement {
     /** Reference to the group member */
-    entity: Reference<"Patient" | "PractitionerRole" | "Medication" | "Device" | "Substance" | "Practitioner" | "Group">;
+    entity: Reference<'Patient' | 'PractitionerRole' | 'Medication' | 'Device' | 'Substance' | 'Practitioner' | 'Group'>;
     /** Period member belonged to the group */
     period?: Period;
     /** If member is no longer in group */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Group.js b/vendor/r4/types/hl7-fhir-r4-core/Group.js
index c8ad2e5..403341d 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Group.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Group.js
@@ -1,2 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupType = void 0;
+/** person | animal | practitioner | device | medication | substance */
+var GroupType;
+(function (GroupType) {
+    GroupType["Animal"] = "animal";
+    GroupType["Device"] = "device";
+    GroupType["Medication"] = "medication";
+    GroupType["Person"] = "person";
+    GroupType["Practitioner"] = "practitioner";
+    GroupType["Substance"] = "substance";
+})(GroupType = exports.GroupType || (exports.GroupType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/GuidanceResponse.d.ts b/vendor/r4/types/hl7-fhir-r4-core/GuidanceResponse.d.ts
index e41ae23..a41c597 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/GuidanceResponse.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/GuidanceResponse.d.ts
@@ -9,20 +9,20 @@ import { canonical } from "./canonical";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** A guidance response is the formal response to a guidance request, including any output parameters returned by the evaluation, as well as the description of any proposed actions to be taken. */
 export interface GuidanceResponse extends DomainResource {
+    resourceType: 'GuidanceResponse';
     /** Additional required data */
     dataRequirement?: Array<DataRequirement>;
     moduleCanonical: canonical;
     /** Encounter during which the response was returned */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _status?: Element;
     /** Why guidance is needed */
     reasonCode?: Array<CodeableConcept>;
     /** The output parameters of the evaluation, if any */
-    outputParameters?: Reference<"Parameters">;
+    outputParameters?: Reference<'Parameters'>;
     /** Messages resulting from the evaluation of the artifact or artifacts */
     evaluationMessage?: Array<Reference>;
     /** The identifier of the request associated with this response, if any */
@@ -32,9 +32,9 @@ export interface GuidanceResponse extends DomainResource {
     note?: Array<Annotation>;
     _moduleCanonical: Element;
     /** success | data-requested | data-required | in-progress | failure | entered-in-error */
-    status: code;
+    status: `${GuidanceResponseStatus}`;
     /** Proposed actions, if any */
-    result?: Reference<"RequestGroup" | "CarePlan">;
+    result?: Reference<'RequestGroup' | 'CarePlan'>;
     /** Business identifier */
     identifier?: Array<Identifier>;
     moduleCodeableConcept: CodeableConcept;
@@ -42,10 +42,19 @@ export interface GuidanceResponse extends DomainResource {
     /** When the guidance response was processed */
     occurrenceDateTime?: dateTime;
     /** Patient the request was performed for */
-    subject?: Reference<"Patient" | "Group">;
+    subject?: Reference<'Patient' | 'Group'>;
     /** Device returning the guidance */
-    performer?: Reference<"Device">;
+    performer?: Reference<'Device'>;
     /** Why guidance is needed */
     reasonReference?: Array<Reference>;
     _occurrenceDateTime?: Element;
 }
+/** success | data-requested | data-required | in-progress | failure | entered-in-error */
+export declare enum GuidanceResponseStatus {
+    DataRequested = "data-requested",
+    DataRequired = "data-required",
+    EnteredInError = "entered-in-error",
+    Failure = "failure",
+    InProgress = "in-progress",
+    Success = "success"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/GuidanceResponse.js b/vendor/r4/types/hl7-fhir-r4-core/GuidanceResponse.js
index c8ad2e5..16d7e28 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/GuidanceResponse.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/GuidanceResponse.js
@@ -1,2 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuidanceResponseStatus = void 0;
+/** success | data-requested | data-required | in-progress | failure | entered-in-error */
+var GuidanceResponseStatus;
+(function (GuidanceResponseStatus) {
+    GuidanceResponseStatus["DataRequested"] = "data-requested";
+    GuidanceResponseStatus["DataRequired"] = "data-required";
+    GuidanceResponseStatus["EnteredInError"] = "entered-in-error";
+    GuidanceResponseStatus["Failure"] = "failure";
+    GuidanceResponseStatus["InProgress"] = "in-progress";
+    GuidanceResponseStatus["Success"] = "success";
+})(GuidanceResponseStatus = exports.GuidanceResponseStatus || (exports.GuidanceResponseStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/HealthcareService.d.ts b/vendor/r4/types/hl7-fhir-r4-core/HealthcareService.d.ts
index 0a8480f..c8659fe 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/HealthcareService.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/HealthcareService.d.ts
@@ -14,6 +14,7 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** The details of a healthcare service available at a location. */
 export interface HealthcareService extends DomainResource {
+    resourceType: 'HealthcareService';
     /** Location(s) service is intended for/available to */
     coverageArea?: Array<Reference>;
     _active?: Element;
@@ -29,7 +30,7 @@ export interface HealthcareService extends DomainResource {
     /** Not available during this time due to provided reason */
     notAvailable?: Array<HealthcareServiceNotAvailable>;
     /** Organization that provides this service */
-    providedBy?: Reference<"Organization">;
+    providedBy?: Reference<'Organization'>;
     /** Type of service that may be delivered or performed */
     type?: Array<CodeableConcept>;
     /** Specific eligibility requirements required to use the service */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/HumanName.d.ts b/vendor/r4/types/hl7-fhir-r4-core/HumanName.d.ts
index a3590a8..238f0d7 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/HumanName.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/HumanName.d.ts
@@ -2,7 +2,6 @@
 DON'T MODIFY MANUALLY */
 import { Period } from "./Period";
 import { Element } from "./Element";
-import { code } from "./code";
 /** Base StructureDefinition for HumanName Type: A human's name with the ability to identify parts and usage. */
 export interface HumanName extends Element {
     _family?: Element;
@@ -15,7 +14,7 @@ export interface HumanName extends Element {
     family?: string;
     _prefix?: Array<Element>;
     /** usual | official | temp | nickname | anonymous | old | maiden */
-    use?: code;
+    use?: `${HumanNameUse}`;
     /** Parts that come before the name */
     prefix?: Array<string>;
     _given?: Array<Element>;
@@ -26,3 +25,13 @@ export interface HumanName extends Element {
     /** Text representation of the full name */
     text?: string;
 }
+/** usual | official | temp | nickname | anonymous | old | maiden */
+export declare enum HumanNameUse {
+    Anonymous = "anonymous",
+    Maiden = "maiden",
+    Nickname = "nickname",
+    Official = "official",
+    Old = "old",
+    Temp = "temp",
+    Usual = "usual"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/HumanName.js b/vendor/r4/types/hl7-fhir-r4-core/HumanName.js
index c8ad2e5..3ce64a1 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/HumanName.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/HumanName.js
@@ -1,2 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HumanNameUse = void 0;
+/** usual | official | temp | nickname | anonymous | old | maiden */
+var HumanNameUse;
+(function (HumanNameUse) {
+    HumanNameUse["Anonymous"] = "anonymous";
+    HumanNameUse["Maiden"] = "maiden";
+    HumanNameUse["Nickname"] = "nickname";
+    HumanNameUse["Official"] = "official";
+    HumanNameUse["Old"] = "old";
+    HumanNameUse["Temp"] = "temp";
+    HumanNameUse["Usual"] = "usual";
+})(HumanNameUse = exports.HumanNameUse || (exports.HumanNameUse = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Identifier.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Identifier.d.ts
index 25df8ea..df15f00 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Identifier.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Identifier.d.ts
@@ -5,15 +5,14 @@ import { CodeableConcept } from "./CodeableConcept";
 import { uri } from "./uri";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 /** Base StructureDefinition for Identifier Type: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers. */
 export interface Identifier extends Element {
     /** Organization that issued id (may be just text) */
-    assigner?: Reference<"Organization">;
+    assigner?: Reference<'Organization'>;
     /** The namespace for the identifier value */
     system?: uri;
     /** usual | official | temp | secondary | old (If known) */
-    use?: code;
+    use?: `${IdentifierUse}`;
     /** The value that is unique */
     value?: string;
     /** Description of identifier */
@@ -24,3 +23,11 @@ export interface Identifier extends Element {
     _system?: Element;
     _use?: Element;
 }
+/** usual | official | temp | secondary | old (If known) */
+export declare enum IdentifierUse {
+    Official = "official",
+    Old = "old",
+    Secondary = "secondary",
+    Temp = "temp",
+    Usual = "usual"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Identifier.js b/vendor/r4/types/hl7-fhir-r4-core/Identifier.js
index c8ad2e5..a44d69b 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Identifier.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Identifier.js
@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentifierUse = void 0;
+/** usual | official | temp | secondary | old (If known) */
+var IdentifierUse;
+(function (IdentifierUse) {
+    IdentifierUse["Official"] = "official";
+    IdentifierUse["Old"] = "old";
+    IdentifierUse["Secondary"] = "secondary";
+    IdentifierUse["Temp"] = "temp";
+    IdentifierUse["Usual"] = "usual";
+})(IdentifierUse = exports.IdentifierUse || (exports.IdentifierUse = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ImagingStudy.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ImagingStudy.d.ts
index 4c62acb..681ad9e 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ImagingStudy.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ImagingStudy.d.ts
@@ -9,11 +9,11 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Representation of the content produced in a DICOM imaging study. A study comprises a set of series, each of which includes a set of Service-Object Pair Instances (SOP Instances - images or other data) acquired or produced in a common context.  A series is of only one modality (e.g. X-ray, CT, MR, ultrasound), but a study may have multiple series of different modalities. */
 export interface ImagingStudy extends DomainResource {
+    resourceType: 'ImagingStudy';
     /** Institution-generated description */
     description?: string;
     /** When the study was started */
@@ -25,9 +25,9 @@ export interface ImagingStudy extends DomainResource {
     /** Each study has one or more series of instances */
     series?: Array<ImagingStudySeries>;
     /** The performed Procedure reference */
-    procedureReference?: Reference<"Procedure">;
+    procedureReference?: Reference<'Procedure'>;
     /** Encounter with which this imaging study is associated */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _numberOfSeries?: Element;
     _status?: Element;
     /** Why the study was requested */
@@ -39,20 +39,20 @@ export interface ImagingStudy extends DomainResource {
     /** User-defined comments */
     note?: Array<Annotation>;
     /** Referring physician */
-    referrer?: Reference<"PractitionerRole" | "Practitioner">;
+    referrer?: Reference<'PractitionerRole' | 'Practitioner'>;
     _started?: Element;
     /** registered | available | cancelled | entered-in-error | unknown */
-    status: code;
+    status: `${ImagingStudyStatus}`;
     /** Identifiers for the whole study */
     identifier?: Array<Identifier>;
     /** Request fulfilled */
     basedOn?: Array<Reference>;
     /** Where ImagingStudy occurred */
-    location?: Reference<"Location">;
+    location?: Reference<'Location'>;
     /** Study access endpoint */
     endpoint?: Array<Reference>;
     /** Who or what is the subject of the study */
-    subject: Reference<"Patient" | "Device" | "Group">;
+    subject: Reference<'Patient' | 'Device' | 'Group'>;
     /** Number of Study Related Instances */
     numberOfInstances?: unsignedInt;
     /** Why was study performed */
@@ -79,7 +79,7 @@ export interface ImagingStudyPerformer extends BackboneElement {
     /** Type of performance */
     function?: CodeableConcept;
     /** Who performed the series */
-    actor: Reference<"CareTeam" | "Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    actor: Reference<'CareTeam' | 'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
 }
 /** Each study has one or more series of instances */
 export interface ImagingStudySeries extends BackboneElement {
@@ -113,3 +113,11 @@ export interface ImagingStudySeries extends BackboneElement {
     /** Who performed the series */
     performer?: Array<ImagingStudyPerformer>;
 }
+/** registered | available | cancelled | entered-in-error | unknown */
+export declare enum ImagingStudyStatus {
+    Available = "available",
+    Cancelled = "cancelled",
+    EnteredInError = "entered-in-error",
+    Registered = "registered",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ImagingStudy.js b/vendor/r4/types/hl7-fhir-r4-core/ImagingStudy.js
index c8ad2e5..d887bf2 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ImagingStudy.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ImagingStudy.js
@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImagingStudyStatus = void 0;
+/** registered | available | cancelled | entered-in-error | unknown */
+var ImagingStudyStatus;
+(function (ImagingStudyStatus) {
+    ImagingStudyStatus["Available"] = "available";
+    ImagingStudyStatus["Cancelled"] = "cancelled";
+    ImagingStudyStatus["EnteredInError"] = "entered-in-error";
+    ImagingStudyStatus["Registered"] = "registered";
+    ImagingStudyStatus["Unknown"] = "unknown";
+})(ImagingStudyStatus = exports.ImagingStudyStatus || (exports.ImagingStudyStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Immunization.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Immunization.d.ts
index 226d276..470e6f5 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Immunization.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Immunization.d.ts
@@ -10,13 +10,13 @@ import { DomainResource } from "./DomainResource";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Describes the event of a patient being administered a vaccine or a record of an immunization as reported by a patient, a clinician or another party. */
 export interface Immunization extends DomainResource {
+    resourceType: 'Immunization';
     /** Who was immunized */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** Dose potency */
     isSubpotent?: boolean;
     /** Indicates the source of a secondarily reported record */
@@ -27,7 +27,7 @@ export interface Immunization extends DomainResource {
     site?: CodeableConcept;
     _isSubpotent?: Element;
     /** Encounter immunization was part of */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     /** Vaccine product administered */
     vaccineCode: CodeableConcept;
     /** Amount of vaccine administered */
@@ -49,13 +49,13 @@ export interface Immunization extends DomainResource {
     /** Indicates context the data was recorded in */
     primarySource?: boolean;
     /** completed | entered-in-error | not-done */
-    status: code;
+    status: `${ImmunizationStatus}`;
     /** Vaccine lot number */
     lotNumber?: string;
     /** Business identifier */
     identifier?: Array<Identifier>;
     /** Vaccine manufacturer */
-    manufacturer?: Reference<"Organization">;
+    manufacturer?: Reference<'Organization'>;
     /** Educational material presented to patient */
     education?: Array<ImmunizationEducation>;
     _primarySource?: Element;
@@ -65,7 +65,7 @@ export interface Immunization extends DomainResource {
     /** Details of a reaction that follows immunization */
     reaction?: Array<ImmunizationReaction>;
     /** Where immunization occurred */
-    location?: Reference<"Location">;
+    location?: Reference<'Location'>;
     occurrenceDateTime: dateTime;
     _occurrenceString: Element;
     /** Funding source for the vaccine */
@@ -88,7 +88,7 @@ export interface ImmunizationProtocolApplied extends BackboneElement {
     /** Name of vaccine series */
     series?: string;
     /** Who is responsible for publishing the recommendations */
-    authority?: Reference<"Organization">;
+    authority?: Reference<'Organization'>;
     _doseNumberPositiveInt: Element;
     doseNumberString: string;
     seriesDosesString?: string;
@@ -98,6 +98,12 @@ export interface ImmunizationProtocolApplied extends BackboneElement {
     _series?: Element;
     _seriesDosesPositiveInt?: Element;
 }
+/** completed | entered-in-error | not-done */
+export declare enum ImmunizationStatus {
+    Completed = "completed",
+    EnteredInError = "entered-in-error",
+    NotDone = "not-done"
+}
 /** Educational material presented to patient */
 export interface ImmunizationEducation extends BackboneElement {
     /** Educational material document identifier */
@@ -119,7 +125,7 @@ export interface ImmunizationReaction extends BackboneElement {
     date?: dateTime;
     _date?: Element;
     /** Additional information on reaction */
-    detail?: Reference<"Observation">;
+    detail?: Reference<'Observation'>;
     /** Indicates self-reported reaction */
     reported?: boolean;
     _reported?: Element;
@@ -129,5 +135,5 @@ export interface ImmunizationPerformer extends BackboneElement {
     /** What type of performance was done */
     function?: CodeableConcept;
     /** Individual or organization who was performing */
-    actor: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    actor: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Immunization.js b/vendor/r4/types/hl7-fhir-r4-core/Immunization.js
index c8ad2e5..05c3b3f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Immunization.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Immunization.js
@@ -1,2 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImmunizationStatus = void 0;
+/** completed | entered-in-error | not-done */
+var ImmunizationStatus;
+(function (ImmunizationStatus) {
+    ImmunizationStatus["Completed"] = "completed";
+    ImmunizationStatus["EnteredInError"] = "entered-in-error";
+    ImmunizationStatus["NotDone"] = "not-done";
+})(ImmunizationStatus = exports.ImmunizationStatus || (exports.ImmunizationStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ImmunizationEvaluation.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ImmunizationEvaluation.d.ts
index 23d1dec..c57dc1a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ImmunizationEvaluation.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ImmunizationEvaluation.d.ts
@@ -6,12 +6,12 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those  recommendations. */
 export interface ImmunizationEvaluation extends DomainResource {
+    resourceType: 'ImmunizationEvaluation';
     /** Who this evaluation is for */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** Evaluation notes */
     description?: string;
     seriesDosesPositiveInt?: positiveInt;
@@ -23,7 +23,7 @@ export interface ImmunizationEvaluation extends DomainResource {
     series?: string;
     _date?: Element;
     /** Who is responsible for publishing the recommendations */
-    authority?: Reference<"Organization">;
+    authority?: Reference<'Organization'>;
     _status?: Element;
     _doseNumberPositiveInt?: Element;
     doseNumberString?: string;
@@ -32,10 +32,10 @@ export interface ImmunizationEvaluation extends DomainResource {
     /** Reason for the dose status */
     doseStatusReason?: Array<CodeableConcept>;
     /** Immunization being evaluated */
-    immunizationEvent: Reference<"Immunization">;
+    immunizationEvent: Reference<'Immunization'>;
     _seriesDosesString?: Element;
     /** completed | entered-in-error */
-    status: code;
+    status: `${ImmunizationEvaluationStatus}`;
     /** Business identifier */
     identifier?: Array<Identifier>;
     /** Evaluation target disease */
@@ -45,3 +45,8 @@ export interface ImmunizationEvaluation extends DomainResource {
     _series?: Element;
     _seriesDosesPositiveInt?: Element;
 }
+/** completed | entered-in-error */
+export declare enum ImmunizationEvaluationStatus {
+    Completed = "completed",
+    EnteredInError = "entered-in-error"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ImmunizationEvaluation.js b/vendor/r4/types/hl7-fhir-r4-core/ImmunizationEvaluation.js
index c8ad2e5..b19d1ed 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ImmunizationEvaluation.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ImmunizationEvaluation.js
@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImmunizationEvaluationStatus = void 0;
+/** completed | entered-in-error */
+var ImmunizationEvaluationStatus;
+(function (ImmunizationEvaluationStatus) {
+    ImmunizationEvaluationStatus["Completed"] = "completed";
+    ImmunizationEvaluationStatus["EnteredInError"] = "entered-in-error";
+})(ImmunizationEvaluationStatus = exports.ImmunizationEvaluationStatus || (exports.ImmunizationEvaluationStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ImmunizationRecommendation.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ImmunizationRecommendation.d.ts
index 7907ad9..ab18289 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ImmunizationRecommendation.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ImmunizationRecommendation.d.ts
@@ -10,15 +10,16 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification. */
 export interface ImmunizationRecommendation extends DomainResource {
+    resourceType: 'ImmunizationRecommendation';
     /** Business identifier */
     identifier?: Array<Identifier>;
     /** Who this profile is for */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** Date recommendation(s) created */
     date: dateTime;
     _date?: Element;
     /** Who is responsible for protocol */
-    authority?: Reference<"Organization">;
+    authority?: Reference<'Organization'>;
     /** Vaccine administration recommendations */
     recommendation: Array<ImmunizationRecommendationRecommendation>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ImplementationGuide.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ImplementationGuide.d.ts
index 46c0b24..1714507 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ImplementationGuide.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ImplementationGuide.d.ts
@@ -16,6 +16,7 @@ import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts. */
 export interface ImplementationGuide extends DomainResource {
+    resourceType: 'ImplementationGuide';
     /** Natural language description of the implementation guide */
     description?: markdown;
     /** Information needed to build the IG */
@@ -28,7 +29,7 @@ export interface ImplementationGuide extends DomainResource {
     /** FHIR Version(s) this Implementation Guide targets */
     fhirVersion: Array<code>;
     /** SPDX license code for this IG (or not-open-source) */
-    license?: code;
+    license?: `${ImplementationGuideLicense}`;
     /** Intended jurisdiction for implementation guide (if applicable) */
     jurisdiction?: Array<CodeableConcept>;
     _publisher?: Element;
@@ -54,7 +55,7 @@ export interface ImplementationGuide extends DomainResource {
     title?: string;
     _description?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${ImplementationGuideStatus}`;
     _name?: Element;
     /** Canonical identifier for this implementation guide, represented as a URI (globally unique) */
     url: uri;
@@ -70,6 +71,13 @@ export interface ImplementationGuide extends DomainResource {
     contact?: Array<ContactDetail>;
     _url?: Element;
 }
+/** draft | active | retired | unknown */
+export declare enum ImplementationGuideStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
 /** Grouping used to present related resources in the IG */
 export interface ImplementationGuideGrouping extends BackboneElement {
     /** Descriptive name for the package */
@@ -83,8 +91,8 @@ export interface ImplementationGuideGrouping extends BackboneElement {
 export interface ImplementationGuideDefinitionPage extends BackboneElement {
     _nameUrl: Element;
     /** html | markdown | xml | generated */
-    generation: code;
-    nameReference: Reference<"Binary">;
+    generation: `${ImplementationGuideDefinitionPageGeneration}`;
+    nameReference: Reference<'Binary'>;
     nameUrl: url;
     /** Nested Pages / Sections */
     page?: Array<ImplementationGuideDefinitionPage>;
@@ -130,10 +138,17 @@ export interface ImplementationGuideManifest extends BackboneElement {
     other?: Array<string>;
     _other?: Array<Element>;
 }
+/** html | markdown | xml | generated */
+export declare enum ImplementationGuideDefinitionPageGeneration {
+    Generated = "generated",
+    Html = "html",
+    Markdown = "markdown",
+    Xml = "xml"
+}
 /** Profiles that apply globally */
 export interface ImplementationGuideGlobal extends BackboneElement {
     /** Type this profile applies to */
-    type: code;
+    type: `${ImplementationGuideType}`;
     _type?: Element;
     /** Profile that all resources must conform to */
     profile: canonical;
@@ -151,6 +166,157 @@ export interface ImplementationGuideTemplate extends BackboneElement {
     scope?: string;
     _scope?: Element;
 }
+/** Type this profile applies to */
+export declare enum ImplementationGuideType {
+    ImmunizationEvaluation = "ImmunizationEvaluation",
+    Appointment = "Appointment",
+    StructureMap = "StructureMap",
+    CareTeam = "CareTeam",
+    Linkage = "Linkage",
+    Communication = "Communication",
+    MedicationDispense = "MedicationDispense",
+    ImagingStudy = "ImagingStudy",
+    ChargeItem = "ChargeItem",
+    AdverseEvent = "AdverseEvent",
+    Media = "Media",
+    SubstancePolymer = "SubstancePolymer",
+    QuestionnaireResponse = "QuestionnaireResponse",
+    Coverage = "Coverage",
+    Procedure = "Procedure",
+    AuditEvent = "AuditEvent",
+    PaymentReconciliation = "PaymentReconciliation",
+    MedicinalProductManufactured = "MedicinalProductManufactured",
+    CompartmentDefinition = "CompartmentDefinition",
+    Organization = "Organization",
+    ExplanationOfBenefit = "ExplanationOfBenefit",
+    Composition = "Composition",
+    CoverageEligibilityResponse = "CoverageEligibilityResponse",
+    DocumentReference = "DocumentReference",
+    EventDefinition = "EventDefinition",
+    SubstanceProtein = "SubstanceProtein",
+    TerminologyCapabilities = "TerminologyCapabilities",
+    Encounter = "Encounter",
+    ImplementationGuide = "ImplementationGuide",
+    EvidenceVariable = "EvidenceVariable",
+    ObservationDefinition = "ObservationDefinition",
+    DiagnosticReport = "DiagnosticReport",
+    ExampleScenario = "ExampleScenario",
+    ResearchDefinition = "ResearchDefinition",
+    Parameters = "Parameters",
+    SearchParameter = "SearchParameter",
+    MedicinalProductInteraction = "MedicinalProductInteraction",
+    CodeSystem = "CodeSystem",
+    MessageDefinition = "MessageDefinition",
+    NutritionOrder = "NutritionOrder",
+    VerificationResult = "VerificationResult",
+    MedicationAdministration = "MedicationAdministration",
+    CatalogEntry = "CatalogEntry",
+    Flag = "Flag",
+    DeviceUseStatement = "DeviceUseStatement",
+    Contract = "Contract",
+    Invoice = "Invoice",
+    PaymentNotice = "PaymentNotice",
+    Location = "Location",
+    Claim = "Claim",
+    Specimen = "Specimen",
+    MedicationStatement = "MedicationStatement",
+    EnrollmentResponse = "EnrollmentResponse",
+    Evidence = "Evidence",
+    Bundle = "Bundle",
+    ResearchElementDefinition = "ResearchElementDefinition",
+    BodyStructure = "BodyStructure",
+    MedicinalProduct = "MedicinalProduct",
+    ResearchStudy = "ResearchStudy",
+    AppointmentResponse = "AppointmentResponse",
+    MedicinalProductIndication = "MedicinalProductIndication",
+    Measure = "Measure",
+    Person = "Person",
+    InsurancePlan = "InsurancePlan",
+    Patient = "Patient",
+    EffectEvidenceSynthesis = "EffectEvidenceSynthesis",
+    ResearchSubject = "ResearchSubject",
+    Medication = "Medication",
+    ConceptMap = "ConceptMap",
+    CoverageEligibilityRequest = "CoverageEligibilityRequest",
+    SubstanceSourceMaterial = "SubstanceSourceMaterial",
+    VisionPrescription = "VisionPrescription",
+    MolecularSequence = "MolecularSequence",
+    MedicinalProductUndesirableEffect = "MedicinalProductUndesirableEffect",
+    OperationOutcome = "OperationOutcome",
+    MessageHeader = "MessageHeader",
+    AllergyIntolerance = "AllergyIntolerance",
+    SubstanceReferenceInformation = "SubstanceReferenceInformation",
+    SupplyDelivery = "SupplyDelivery",
+    EpisodeOfCare = "EpisodeOfCare",
+    PractitionerRole = "PractitionerRole",
+    Library = "Library",
+    Practitioner = "Practitioner",
+    MedicationRequest = "MedicationRequest",
+    ImmunizationRecommendation = "ImmunizationRecommendation",
+    Immunization = "Immunization",
+    GraphDefinition = "GraphDefinition",
+    Account = "Account",
+    MedicinalProductIngredient = "MedicinalProductIngredient",
+    MeasureReport = "MeasureReport",
+    DeviceMetric = "DeviceMetric",
+    Goal = "Goal",
+    MedicationKnowledge = "MedicationKnowledge",
+    ClaimResponse = "ClaimResponse",
+    DeviceDefinition = "DeviceDefinition",
+    Slot = "Slot",
+    ValueSet = "ValueSet",
+    MedicinalProductAuthorization = "MedicinalProductAuthorization",
+    StructureDefinition = "StructureDefinition",
+    MedicinalProductContraindication = "MedicinalProductContraindication",
+    DeviceRequest = "DeviceRequest",
+    List = "List",
+    Questionnaire = "Questionnaire",
+    DomainResource = "DomainResource",
+    Endpoint = "Endpoint",
+    NamingSystem = "NamingSystem",
+    MedicinalProductPackaged = "MedicinalProductPackaged",
+    Basic = "Basic",
+    Binary = "Binary",
+    PlanDefinition = "PlanDefinition",
+    Subscription = "Subscription",
+    RelatedPerson = "RelatedPerson",
+    SubstanceSpecification = "SubstanceSpecification",
+    SubstanceNucleicAcid = "SubstanceNucleicAcid",
+    GuidanceResponse = "GuidanceResponse",
+    ClinicalImpression = "ClinicalImpression",
+    OrganizationAffiliation = "OrganizationAffiliation",
+    Resource = "Resource",
+    Condition = "Condition",
+    CapabilityStatement = "CapabilityStatement",
+    HealthcareService = "HealthcareService",
+    SpecimenDefinition = "SpecimenDefinition",
+    RiskAssessment = "RiskAssessment",
+    OperationDefinition = "OperationDefinition",
+    ActivityDefinition = "ActivityDefinition",
+    Schedule = "Schedule",
+    BiologicallyDerivedProduct = "BiologicallyDerivedProduct",
+    Group = "Group",
+    MedicinalProductPharmaceutical = "MedicinalProductPharmaceutical",
+    FamilyMemberHistory = "FamilyMemberHistory",
+    ServiceRequest = "ServiceRequest",
+    DetectedIssue = "DetectedIssue",
+    Device = "Device",
+    RequestGroup = "RequestGroup",
+    TestScript = "TestScript",
+    RiskEvidenceSynthesis = "RiskEvidenceSynthesis",
+    SupplyRequest = "SupplyRequest",
+    Task = "Task",
+    CommunicationRequest = "CommunicationRequest",
+    EnrollmentRequest = "EnrollmentRequest",
+    ChargeItemDefinition = "ChargeItemDefinition",
+    Substance = "Substance",
+    Provenance = "Provenance",
+    Consent = "Consent",
+    CarePlan = "CarePlan",
+    TestReport = "TestReport",
+    Observation = "Observation",
+    DocumentManifest = "DocumentManifest"
+}
 /** Information needed to build the IG */
 export interface ImplementationGuideDefinition extends BackboneElement {
     /** Grouping used to present related resources in the IG */
@@ -163,15 +329,377 @@ export interface ImplementationGuideDefinition extends BackboneElement {
     /** A template for building resources */
     template?: Array<ImplementationGuideTemplate>;
 }
+/** apply | path-resource | path-pages | path-tx-cache | expansion-parameter | rule-broken-links | generate-xml | generate-json | generate-turtle | html-template */
+export declare enum ImplementationGuideCode {
+    RuleBrokenLinks = "rule-broken-links",
+    GenerateJson = "generate-json",
+    GenerateTurtle = "generate-turtle",
+    PathResource = "path-resource",
+    PathPages = "path-pages",
+    GenerateXml = "generate-xml",
+    PathTxCache = "path-tx-cache",
+    ExpansionParameter = "expansion-parameter",
+    Apply = "apply",
+    HtmlTemplate = "html-template"
+}
 /** Defines how IG is built by tools */
 export interface ImplementationGuideParameter extends BackboneElement {
     /** apply | path-resource | path-pages | path-tx-cache | expansion-parameter | rule-broken-links | generate-xml | generate-json | generate-turtle | html-template */
-    code: code;
+    code: `${ImplementationGuideCode}`;
     _code?: Element;
     /** Value for named type */
     value: string;
     _value?: Element;
 }
+/** SPDX license code for this IG (or not-open-source) */
+export declare enum ImplementationGuideLicense {
+    "CCBYNCSANum1.0" = "CC-BY-NC-SA-1.0",
+    "QPLNum1.0" = "QPL-1.0",
+    "WatcomNum1.0" = "Watcom-1.0",
+    Noweb = "Noweb",
+    Multics = "Multics",
+    "NPLNum1.0" = "NPL-1.0",
+    "PDDLNum1.0" = "PDDL-1.0",
+    CNRIJython = "CNRI-Jython",
+    "GFDLNum1.3Only" = "GFDL-1.3-only",
+    Zlib = "Zlib",
+    SAXPD = "SAX-PD",
+    Afmparse = "Afmparse",
+    "LGPLNum2.0Only" = "LGPL-2.0-only",
+    HaskellReport = "HaskellReport",
+    "CCBYNCNDNum3.0" = "CC-BY-NC-ND-3.0",
+    ICU = "ICU",
+    "CCBYNCSANum2.5" = "CC-BY-NC-SA-2.5",
+    CECILLC = "CECILL-C",
+    "BSLNum1.0" = "BSL-1.0",
+    AdobeNum2006 = "Adobe-2006",
+    "OLDAPNum1.1" = "OLDAP-1.1",
+    Curl = "curl",
+    "GPLNum2.0OrLater" = "GPL-2.0-or-later",
+    "OLDAPNum2.4" = "OLDAP-2.4",
+    "MPLNum1.0" = "MPL-1.0",
+    Num0BSD = "0BSD",
+    SISSL = "SISSL",
+    Plexus = "Plexus",
+    Barr = "Barr",
+    "OFLNum1.0" = "OFL-1.0",
+    Caldera = "Caldera",
+    "NPOSLNum3.0" = "NPOSL-3.0",
+    Xinetd = "xinetd",
+    "OLDAPNum2.1" = "OLDAP-2.1",
+    Xpp = "xpp",
+    "CDDLNum1.1" = "CDDL-1.1",
+    "CCBYNDNum2.0" = "CC-BY-ND-2.0",
+    "OCLCNum2.0" = "OCLC-2.0",
+    MITAdvertising = "MIT-advertising",
+    "EUPLNum1.2" = "EUPL-1.2",
+    "SimPLNum2.0" = "SimPL-2.0",
+    "InterbaseNum1.0" = "Interbase-1.0",
+    APAFML = "APAFML",
+    Qhull = "Qhull",
+    "CCBYNCNum2.0" = "CC-BY-NC-2.0",
+    Psutils = "psutils",
+    BSDNum3ClauseClear = "BSD-3-Clause-Clear",
+    CECILLB = "CECILL-B",
+    "OFLNum1.1" = "OFL-1.1",
+    OGTSL = "OGTSL",
+    "OLDAPNum2.2" = "OLDAP-2.2",
+    "ErlPLNum1.1" = "ErlPL-1.1",
+    "SISSLNum1.2" = "SISSL-1.2",
+    BSDNum2ClausePatent = "BSD-2-Clause-Patent",
+    MTLL = "MTLL",
+    "NPLNum1.1" = "NPL-1.1",
+    BSDNum3ClauseAttribution = "BSD-3-Clause-Attribution",
+    NCSA = "NCSA",
+    OpenSSL = "OpenSSL",
+    Giftware = "Giftware",
+    "NLODNum1.0" = "NLOD-1.0",
+    "GSOAPNum1.3b" = "gSOAP-1.3b",
+    TCL = "TCL",
+    XSkat = "XSkat",
+    AMDPLPA = "AMDPLPA",
+    "CCBYNDNum1.0" = "CC-BY-ND-1.0",
+    NLPL = "NLPL",
+    DOC = "DOC",
+    AML = "AML",
+    "CPLNum1.0" = "CPL-1.0",
+    ANTLRPD = "ANTLR-PD",
+    "CCBYSANum2.5" = "CC-BY-SA-2.5",
+    "AFLNum2.1" = "AFL-2.1",
+    "RHeCosNum1.1" = "RHeCos-1.1",
+    "CCBYNCSANum3.0" = "CC-BY-NC-SA-3.0",
+    "APSLNum2.0" = "APSL-2.0",
+    AAL = "AAL",
+    "CCBYNCSANum2.0" = "CC-BY-NC-SA-2.0",
+    SMLNJ = "SMLNJ",
+    CNRIPython = "CNRI-Python",
+    "VSLNum1.0" = "VSL-1.0",
+    "OLDAPNum2.2.2" = "OLDAP-2.2.2",
+    Beerware = "Beerware",
+    "Bzip2Num1.0.6" = "bzip2-1.0.6",
+    "LGPLNum3.0OrLater" = "LGPL-3.0-or-later",
+    "YPLNum1.0" = "YPL-1.0",
+    "APLNum1.0" = "APL-1.0",
+    "GFDLNum1.2OrLater" = "GFDL-1.2-or-later",
+    "LiLiQPNum1.1" = "LiLiQ-P-1.1",
+    FreeImage = "FreeImage",
+    "CPOLNum1.02" = "CPOL-1.02",
+    "BitTorrentNum1.0" = "BitTorrent-1.0",
+    BSDNum3ClauseNoNuclearWarranty = "BSD-3-Clause-No-Nuclear-Warranty",
+    Dotseqn = "Dotseqn",
+    "ArtisticNum2.0" = "Artistic-2.0",
+    NTP = "NTP",
+    Newsletr = "Newsletr",
+    "RPLNum1.5" = "RPL-1.5",
+    NRL = "NRL",
+    MSRL = "MS-RL",
+    "CCBYNum2.5" = "CC-BY-2.5",
+    "AGPLNum3.0Only" = "AGPL-3.0-only",
+    "GFDLNum1.2Only" = "GFDL-1.2-only",
+    MITNFA = "MITNFA",
+    BSDNum2ClauseNetBSD = "BSD-2-Clause-NetBSD",
+    FSFUL = "FSFUL",
+    "CCBYNCNDNum4.0" = "CC-BY-NC-ND-4.0",
+    Saxpath = "Saxpath",
+    "RPLNum1.1" = "RPL-1.1",
+    "FrameworxNum1.0" = "Frameworx-1.0",
+    "OLDAPNum2.0" = "OLDAP-2.0",
+    FSFAP = "FSFAP",
+    Leptonica = "Leptonica",
+    "CATOSLNum1.1" = "CATOSL-1.1",
+    "Bzip2Num1.0.5" = "bzip2-1.0.5",
+    BSDProtection = "BSD-Protection",
+    Xerox = "Xerox",
+    Imlib2 = "Imlib2",
+    "CCBYNDNum4.0" = "CC-BY-ND-4.0",
+    Psfrag = "psfrag",
+    W3CNum20150513 = "W3C-20150513",
+    EGenix = "eGenix",
+    "LALNum1.3" = "LAL-1.3",
+    "EUPLNum1.0" = "EUPL-1.0",
+    "CCBYNCNum2.5" = "CC-BY-NC-2.5",
+    "GPLNum2.0Only" = "GPL-2.0-only",
+    Fair = "Fair",
+    MITEnna = "MIT-enna",
+    BSDNum4Clause = "BSD-4-Clause",
+    RSCPL = "RSCPL",
+    "ZendNum2.0" = "Zend-2.0",
+    InfoZIP = "Info-ZIP",
+    "CCBYNCNum1.0" = "CC-BY-NC-1.0",
+    BSDNum2Clause = "BSD-2-Clause",
+    "OLDAPNum2.7" = "OLDAP-2.7",
+    "ODbLNum1.0" = "ODbL-1.0",
+    "APSLNum1.0" = "APSL-1.0",
+    "ECLNum1.0" = "ECL-1.0",
+    "ApacheNum1.0" = "Apache-1.0",
+    "AGPLNum3.0OrLater" = "AGPL-3.0-or-later",
+    Intel = "Intel",
+    "ArtisticNum1.0Perl" = "Artistic-1.0-Perl",
+    "GFDLNum1.3OrLater" = "GFDL-1.3-or-later",
+    "GPLNum1.0Only" = "GPL-1.0-only",
+    AMPAS = "AMPAS",
+    BSDNum4ClauseUC = "BSD-4-Clause-UC",
+    "SGIBNum1.1" = "SGI-B-1.1",
+    IntelACPI = "Intel-ACPI",
+    "EPLNum2.0" = "EPL-2.0",
+    Ruby = "Ruby",
+    Glulxe = "Glulxe",
+    Aladdin = "Aladdin",
+    Sendmail = "Sendmail",
+    "LPLNum1.0" = "LPL-1.0",
+    "CPALNum1.0" = "CPAL-1.0",
+    "CECILLNum2.1" = "CECILL-2.1",
+    "ZPLNum2.1" = "ZPL-2.1",
+    "UPLNum1.0" = "UPL-1.0",
+    "LGPLNum2.1OrLater" = "LGPL-2.1-or-later",
+    "OLDAPNum2.8" = "OLDAP-2.8",
+    "OSETPLNum2.1" = "OSET-PL-2.1",
+    EUDatagrid = "EUDatagrid",
+    "RPSLNum1.0" = "RPSL-1.0",
+    SpencerNum99 = "Spencer-99",
+    "OSLNum2.0" = "OSL-2.0",
+    "YPLNum1.1" = "YPL-1.1",
+    MITCMU = "MIT-CMU",
+    TMate = "TMate",
+    IBMPibs = "IBM-pibs",
+    "AFLNum2.0" = "AFL-2.0",
+    UnicodeDFSNum2015 = "Unicode-DFS-2015",
+    CNRIPythonGPLCompatible = "CNRI-Python-GPL-Compatible",
+    DSDP = "DSDP",
+    "MPLNum2.0NoCopyleftException" = "MPL-2.0-no-copyleft-exception",
+    W3C = "W3C",
+    "OLDAPNum1.2" = "OLDAP-1.2",
+    "CDLASharingNum1.0" = "CDLA-Sharing-1.0",
+    "LiLiQRNum1.1" = "LiLiQ-R-1.1",
+    "ZPLNum1.1" = "ZPL-1.1",
+    "CC0Num1.0" = "CC0-1.0",
+    SWL = "SWL",
+    "PythonNum2.0" = "Python-2.0",
+    "OLDAPNum1.4" = "OLDAP-1.4",
+    "LPPLNum1.1" = "LPPL-1.1",
+    "LPPLNum1.3c" = "LPPL-1.3c",
+    Unlicense = "Unlicense",
+    SpencerNum94 = "Spencer-94",
+    Cube = "Cube",
+    ZlibAcknowledgement = "zlib-acknowledgement",
+    "CondorNum1.1" = "Condor-1.1",
+    SMPPL = "SMPPL",
+    Libtiff = "libtiff",
+    OML = "OML",
+    "SugarCRMNum1.1.3" = "SugarCRM-1.1.3",
+    "CCBYSANum1.0" = "CC-BY-SA-1.0",
+    BSDNum3ClauseNoNuclearLicenseNum2014 = "BSD-3-Clause-No-Nuclear-License-2014",
+    VOSTROM = "VOSTROM",
+    "CCBYSANum4.0" = "CC-BY-SA-4.0",
+    "AGPLNum1.0OrLater" = "AGPL-1.0-or-later",
+    "CCBYNDNum3.0" = "CC-BY-ND-3.0",
+    "ZimbraNum1.3" = "Zimbra-1.3",
+    "LGPLNum3.0Only" = "LGPL-3.0-only",
+    "JasPerNum2.0" = "JasPer-2.0",
+    "OLDAPNum2.5" = "OLDAP-2.5",
+    "CCBYNum4.0" = "CC-BY-4.0",
+    ISC = "ISC",
+    ImageMagick = "ImageMagick",
+    MakeIndex = "MakeIndex",
+    JSON = "JSON",
+    CrystalStacker = "CrystalStacker",
+    IMatix = "iMatix",
+    "AGPLNum1.0Only" = "AGPL-1.0-only",
+    "GPLNum3.0OrLater" = "GPL-3.0-or-later",
+    Naumen = "Naumen",
+    "NASANum1.3" = "NASA-1.3",
+    GL2PS = "GL2PS",
+    "CCBYNum1.0" = "CC-BY-1.0",
+    "CCBYNCNum4.0" = "CC-BY-NC-4.0",
+    "LPPLNum1.0" = "LPPL-1.0",
+    "OLDAPNum2.2.1" = "OLDAP-2.2.1",
+    "ArtisticNum1.0Cl8" = "Artistic-1.0-cl8",
+    "OLDAPNum2.0.1" = "OLDAP-2.0.1",
+    SCEA = "SCEA",
+    MITFeh = "MIT-feh",
+    NetSNMP = "Net-SNMP",
+    LGPLLR = "LGPLLR",
+    BSDNum3ClauseNoNuclearLicense = "BSD-3-Clause-No-Nuclear-License",
+    "CCBYSANum2.0" = "CC-BY-SA-2.0",
+    Nokia = "Nokia",
+    "SGIBNum2.0" = "SGI-B-2.0",
+    UnicodeTOU = "Unicode-TOU",
+    RSAMD = "RSA-MD",
+    "CCBYNDNum2.5" = "CC-BY-ND-2.5",
+    "GPLNum3.0Only" = "GPL-3.0-only",
+    "LGPLNum2.0OrLater" = "LGPL-2.0-or-later",
+    IPA = "IPA",
+    "GFDLNum1.1OrLater" = "GFDL-1.1-or-later",
+    "OLDAPNum2.3" = "OLDAP-2.3",
+    Libpng = "Libpng",
+    BSDSourceCode = "BSD-Source-Code",
+    SNIA = "SNIA",
+    "CCBYNCNum3.0" = "CC-BY-NC-3.0",
+    Entessa = "Entessa",
+    "NBPLNum1.0" = "NBPL-1.0",
+    MITNum0 = "MIT-0",
+    "PHPNum3.0" = "PHP-3.0",
+    "DFSLNum1.0" = "D-FSL-1.0",
+    "GFDLNum1.1Only" = "GFDL-1.1-only",
+    "PHPNum3.01" = "PHP-3.01",
+    "ZimbraNum1.4" = "Zimbra-1.4",
+    BSDNum2ClauseFreeBSD = "BSD-2-Clause-FreeBSD",
+    Motosoto = "Motosoto",
+    "CDLAPermissiveNum1.0" = "CDLA-Permissive-1.0",
+    Diffmark = "diffmark",
+    "MPLNum1.1" = "MPL-1.1",
+    "CECILLNum2.0" = "CECILL-2.0",
+    "ApacheNum2.0" = "Apache-2.0",
+    Dvipdfm = "dvipdfm",
+    "CCBYNCSANum4.0" = "CC-BY-NC-SA-4.0",
+    PostgreSQL = "PostgreSQL",
+    "CCBYNCNDNum2.5" = "CC-BY-NC-ND-2.5",
+    MSPL = "MS-PL",
+    BSDNum1Clause = "BSD-1-Clause",
+    "OSLNum1.0" = "OSL-1.0",
+    "CUAOPLNum1.0" = "CUA-OPL-1.0",
+    TCPWrappers = "TCP-wrappers",
+    Mup = "Mup",
+    "APSLNum1.2" = "APSL-1.2",
+    "SGIBNum1.0" = "SGI-B-1.0",
+    "AFLNum1.1" = "AFL-1.1",
+    "OSLNum1.1" = "OSL-1.1",
+    IJG = "IJG",
+    OCCTPL = "OCCT-PL",
+    "MPLNum2.0" = "MPL-2.0",
+    Mpich2 = "mpich2",
+    "CECILLNum1.1" = "CECILL-1.1",
+    "ECLNum2.0" = "ECL-2.0",
+    BSDNum3ClauseLBNL = "BSD-3-Clause-LBNL",
+    TOSL = "TOSL",
+    Crossword = "Crossword",
+    "CCBYNum2.0" = "CC-BY-2.0",
+    AdobeGlyph = "Adobe-Glyph",
+    "OSLNum3.0" = "OSL-3.0",
+    Xnet = "Xnet",
+    "ZPLNum2.0" = "ZPL-2.0",
+    Eurosym = "Eurosym",
+    "TORQUENum1.1" = "TORQUE-1.1",
+    ClArtistic = "ClArtistic",
+    "EUPLNum1.1" = "EUPL-1.1",
+    MIT = "MIT",
+    "LPLNum1.02" = "LPL-1.02",
+    "AFLNum1.2" = "AFL-1.2",
+    NotOpenSource = "not-open-source",
+    UnicodeDFSNum2016 = "Unicode-DFS-2016",
+    Latex2e = "Latex2e",
+    "CCBYNCNDNum2.0" = "CC-BY-NC-ND-2.0",
+    WTFPL = "WTFPL",
+    NetCDF = "NetCDF",
+    "ApacheNum1.1" = "Apache-1.1",
+    "OSLNum2.1" = "OSL-2.1",
+    "EPLNum1.0" = "EPL-1.0",
+    "LPPLNum1.3a" = "LPPL-1.3a",
+    Vim = "Vim",
+    X11 = "X11",
+    W3CNum19980720 = "W3C-19980720",
+    "EFLNum2.0" = "EFL-2.0",
+    "LALNum1.2" = "LAL-1.2",
+    "OLDAPNum1.3" = "OLDAP-1.3",
+    "XFree86Num1.1" = "XFree86-1.1",
+    "CCBYNum3.0" = "CC-BY-3.0",
+    "LGPLNum2.1Only" = "LGPL-2.1-only",
+    Wsuipa = "Wsuipa",
+    "CCBYSANum3.0" = "CC-BY-SA-3.0",
+    BSDNum3Clause = "BSD-3-Clause",
+    Borceux = "Borceux",
+    "ArtisticNum1.0" = "Artistic-1.0",
+    LinuxOpenIB = "Linux-OpenIB",
+    FSFULLR = "FSFULLR",
+    Abstyles = "Abstyles",
+    "SPLNum1.0" = "SPL-1.0",
+    "CECILLNum1.0" = "CECILL-1.0",
+    FTL = "FTL",
+    "CDDLNum1.0" = "CDDL-1.0",
+    "OLDAPNum2.6" = "OLDAP-2.6",
+    Glide = "Glide",
+    "AFLNum3.0" = "AFL-3.0",
+    Rdisc = "Rdisc",
+    "CCBYNCNDNum1.0" = "CC-BY-NC-ND-1.0",
+    NGPL = "NGPL",
+    "EFLNum1.0" = "EFL-1.0",
+    Bahyph = "Bahyph",
+    "LiLiQRplusNum1.1" = "LiLiQ-Rplus-1.1",
+    NOSL = "NOSL",
+    "GPLNum1.0OrLater" = "GPL-1.0-or-later",
+    ADSL = "ADSL",
+    "APSLNum1.1" = "APSL-1.1",
+    HPND = "HPND",
+    Zed = "Zed",
+    SpencerNum86 = "Spencer-86",
+    "BitTorrentNum1.1" = "BitTorrent-1.1",
+    MirOS = "MirOS",
+    "IPLNum1.0" = "IPL-1.0",
+    "OPLNum1.0" = "OPL-1.0",
+    Gnuplot = "gnuplot",
+    Sleepycat = "Sleepycat",
+    "LPPLNum1.2" = "LPPL-1.2"
+}
 /** Another Implementation guide this depends on */
 export interface ImplementationGuideDependsOn extends BackboneElement {
     /** Identity of the IG that this depends on */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ImplementationGuide.js b/vendor/r4/types/hl7-fhir-r4-core/ImplementationGuide.js
index c8ad2e5..803b442 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ImplementationGuide.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ImplementationGuide.js
@@ -1,2 +1,535 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImplementationGuideLicense = exports.ImplementationGuideCode = exports.ImplementationGuideType = exports.ImplementationGuideDefinitionPageGeneration = exports.ImplementationGuideStatus = void 0;
+/** draft | active | retired | unknown */
+var ImplementationGuideStatus;
+(function (ImplementationGuideStatus) {
+    ImplementationGuideStatus["Active"] = "active";
+    ImplementationGuideStatus["Draft"] = "draft";
+    ImplementationGuideStatus["Retired"] = "retired";
+    ImplementationGuideStatus["Unknown"] = "unknown";
+})(ImplementationGuideStatus = exports.ImplementationGuideStatus || (exports.ImplementationGuideStatus = {}));
+/** html | markdown | xml | generated */
+var ImplementationGuideDefinitionPageGeneration;
+(function (ImplementationGuideDefinitionPageGeneration) {
+    ImplementationGuideDefinitionPageGeneration["Generated"] = "generated";
+    ImplementationGuideDefinitionPageGeneration["Html"] = "html";
+    ImplementationGuideDefinitionPageGeneration["Markdown"] = "markdown";
+    ImplementationGuideDefinitionPageGeneration["Xml"] = "xml";
+})(ImplementationGuideDefinitionPageGeneration = exports.ImplementationGuideDefinitionPageGeneration || (exports.ImplementationGuideDefinitionPageGeneration = {}));
+/** Type this profile applies to */
+var ImplementationGuideType;
+(function (ImplementationGuideType) {
+    ImplementationGuideType["ImmunizationEvaluation"] = "ImmunizationEvaluation";
+    ImplementationGuideType["Appointment"] = "Appointment";
+    ImplementationGuideType["StructureMap"] = "StructureMap";
+    ImplementationGuideType["CareTeam"] = "CareTeam";
+    ImplementationGuideType["Linkage"] = "Linkage";
+    ImplementationGuideType["Communication"] = "Communication";
+    ImplementationGuideType["MedicationDispense"] = "MedicationDispense";
+    ImplementationGuideType["ImagingStudy"] = "ImagingStudy";
+    ImplementationGuideType["ChargeItem"] = "ChargeItem";
+    ImplementationGuideType["AdverseEvent"] = "AdverseEvent";
+    ImplementationGuideType["Media"] = "Media";
+    ImplementationGuideType["SubstancePolymer"] = "SubstancePolymer";
+    ImplementationGuideType["QuestionnaireResponse"] = "QuestionnaireResponse";
+    ImplementationGuideType["Coverage"] = "Coverage";
+    ImplementationGuideType["Procedure"] = "Procedure";
+    ImplementationGuideType["AuditEvent"] = "AuditEvent";
+    ImplementationGuideType["PaymentReconciliation"] = "PaymentReconciliation";
+    ImplementationGuideType["MedicinalProductManufactured"] = "MedicinalProductManufactured";
+    ImplementationGuideType["CompartmentDefinition"] = "CompartmentDefinition";
+    ImplementationGuideType["Organization"] = "Organization";
+    ImplementationGuideType["ExplanationOfBenefit"] = "ExplanationOfBenefit";
+    ImplementationGuideType["Composition"] = "Composition";
+    ImplementationGuideType["CoverageEligibilityResponse"] = "CoverageEligibilityResponse";
+    ImplementationGuideType["DocumentReference"] = "DocumentReference";
+    ImplementationGuideType["EventDefinition"] = "EventDefinition";
+    ImplementationGuideType["SubstanceProtein"] = "SubstanceProtein";
+    ImplementationGuideType["TerminologyCapabilities"] = "TerminologyCapabilities";
+    ImplementationGuideType["Encounter"] = "Encounter";
+    ImplementationGuideType["ImplementationGuide"] = "ImplementationGuide";
+    ImplementationGuideType["EvidenceVariable"] = "EvidenceVariable";
+    ImplementationGuideType["ObservationDefinition"] = "ObservationDefinition";
+    ImplementationGuideType["DiagnosticReport"] = "DiagnosticReport";
+    ImplementationGuideType["ExampleScenario"] = "ExampleScenario";
+    ImplementationGuideType["ResearchDefinition"] = "ResearchDefinition";
+    ImplementationGuideType["Parameters"] = "Parameters";
+    ImplementationGuideType["SearchParameter"] = "SearchParameter";
+    ImplementationGuideType["MedicinalProductInteraction"] = "MedicinalProductInteraction";
+    ImplementationGuideType["CodeSystem"] = "CodeSystem";
+    ImplementationGuideType["MessageDefinition"] = "MessageDefinition";
+    ImplementationGuideType["NutritionOrder"] = "NutritionOrder";
+    ImplementationGuideType["VerificationResult"] = "VerificationResult";
+    ImplementationGuideType["MedicationAdministration"] = "MedicationAdministration";
+    ImplementationGuideType["CatalogEntry"] = "CatalogEntry";
+    ImplementationGuideType["Flag"] = "Flag";
+    ImplementationGuideType["DeviceUseStatement"] = "DeviceUseStatement";
+    ImplementationGuideType["Contract"] = "Contract";
+    ImplementationGuideType["Invoice"] = "Invoice";
+    ImplementationGuideType["PaymentNotice"] = "PaymentNotice";
+    ImplementationGuideType["Location"] = "Location";
+    ImplementationGuideType["Claim"] = "Claim";
+    ImplementationGuideType["Specimen"] = "Specimen";
+    ImplementationGuideType["MedicationStatement"] = "MedicationStatement";
+    ImplementationGuideType["EnrollmentResponse"] = "EnrollmentResponse";
+    ImplementationGuideType["Evidence"] = "Evidence";
+    ImplementationGuideType["Bundle"] = "Bundle";
+    ImplementationGuideType["ResearchElementDefinition"] = "ResearchElementDefinition";
+    ImplementationGuideType["BodyStructure"] = "BodyStructure";
+    ImplementationGuideType["MedicinalProduct"] = "MedicinalProduct";
+    ImplementationGuideType["ResearchStudy"] = "ResearchStudy";
+    ImplementationGuideType["AppointmentResponse"] = "AppointmentResponse";
+    ImplementationGuideType["MedicinalProductIndication"] = "MedicinalProductIndication";
+    ImplementationGuideType["Measure"] = "Measure";
+    ImplementationGuideType["Person"] = "Person";
+    ImplementationGuideType["InsurancePlan"] = "InsurancePlan";
+    ImplementationGuideType["Patient"] = "Patient";
+    ImplementationGuideType["EffectEvidenceSynthesis"] = "EffectEvidenceSynthesis";
+    ImplementationGuideType["ResearchSubject"] = "ResearchSubject";
+    ImplementationGuideType["Medication"] = "Medication";
+    ImplementationGuideType["ConceptMap"] = "ConceptMap";
+    ImplementationGuideType["CoverageEligibilityRequest"] = "CoverageEligibilityRequest";
+    ImplementationGuideType["SubstanceSourceMaterial"] = "SubstanceSourceMaterial";
+    ImplementationGuideType["VisionPrescription"] = "VisionPrescription";
+    ImplementationGuideType["MolecularSequence"] = "MolecularSequence";
+    ImplementationGuideType["MedicinalProductUndesirableEffect"] = "MedicinalProductUndesirableEffect";
+    ImplementationGuideType["OperationOutcome"] = "OperationOutcome";
+    ImplementationGuideType["MessageHeader"] = "MessageHeader";
+    ImplementationGuideType["AllergyIntolerance"] = "AllergyIntolerance";
+    ImplementationGuideType["SubstanceReferenceInformation"] = "SubstanceReferenceInformation";
+    ImplementationGuideType["SupplyDelivery"] = "SupplyDelivery";
+    ImplementationGuideType["EpisodeOfCare"] = "EpisodeOfCare";
+    ImplementationGuideType["PractitionerRole"] = "PractitionerRole";
+    ImplementationGuideType["Library"] = "Library";
+    ImplementationGuideType["Practitioner"] = "Practitioner";
+    ImplementationGuideType["MedicationRequest"] = "MedicationRequest";
+    ImplementationGuideType["ImmunizationRecommendation"] = "ImmunizationRecommendation";
+    ImplementationGuideType["Immunization"] = "Immunization";
+    ImplementationGuideType["GraphDefinition"] = "GraphDefinition";
+    ImplementationGuideType["Account"] = "Account";
+    ImplementationGuideType["MedicinalProductIngredient"] = "MedicinalProductIngredient";
+    ImplementationGuideType["MeasureReport"] = "MeasureReport";
+    ImplementationGuideType["DeviceMetric"] = "DeviceMetric";
+    ImplementationGuideType["Goal"] = "Goal";
+    ImplementationGuideType["MedicationKnowledge"] = "MedicationKnowledge";
+    ImplementationGuideType["ClaimResponse"] = "ClaimResponse";
+    ImplementationGuideType["DeviceDefinition"] = "DeviceDefinition";
+    ImplementationGuideType["Slot"] = "Slot";
+    ImplementationGuideType["ValueSet"] = "ValueSet";
+    ImplementationGuideType["MedicinalProductAuthorization"] = "MedicinalProductAuthorization";
+    ImplementationGuideType["StructureDefinition"] = "StructureDefinition";
+    ImplementationGuideType["MedicinalProductContraindication"] = "MedicinalProductContraindication";
+    ImplementationGuideType["DeviceRequest"] = "DeviceRequest";
+    ImplementationGuideType["List"] = "List";
+    ImplementationGuideType["Questionnaire"] = "Questionnaire";
+    ImplementationGuideType["DomainResource"] = "DomainResource";
+    ImplementationGuideType["Endpoint"] = "Endpoint";
+    ImplementationGuideType["NamingSystem"] = "NamingSystem";
+    ImplementationGuideType["MedicinalProductPackaged"] = "MedicinalProductPackaged";
+    ImplementationGuideType["Basic"] = "Basic";
+    ImplementationGuideType["Binary"] = "Binary";
+    ImplementationGuideType["PlanDefinition"] = "PlanDefinition";
+    ImplementationGuideType["Subscription"] = "Subscription";
+    ImplementationGuideType["RelatedPerson"] = "RelatedPerson";
+    ImplementationGuideType["SubstanceSpecification"] = "SubstanceSpecification";
+    ImplementationGuideType["SubstanceNucleicAcid"] = "SubstanceNucleicAcid";
+    ImplementationGuideType["GuidanceResponse"] = "GuidanceResponse";
+    ImplementationGuideType["ClinicalImpression"] = "ClinicalImpression";
+    ImplementationGuideType["OrganizationAffiliation"] = "OrganizationAffiliation";
+    ImplementationGuideType["Resource"] = "Resource";
+    ImplementationGuideType["Condition"] = "Condition";
+    ImplementationGuideType["CapabilityStatement"] = "CapabilityStatement";
+    ImplementationGuideType["HealthcareService"] = "HealthcareService";
+    ImplementationGuideType["SpecimenDefinition"] = "SpecimenDefinition";
+    ImplementationGuideType["RiskAssessment"] = "RiskAssessment";
+    ImplementationGuideType["OperationDefinition"] = "OperationDefinition";
+    ImplementationGuideType["ActivityDefinition"] = "ActivityDefinition";
+    ImplementationGuideType["Schedule"] = "Schedule";
+    ImplementationGuideType["BiologicallyDerivedProduct"] = "BiologicallyDerivedProduct";
+    ImplementationGuideType["Group"] = "Group";
+    ImplementationGuideType["MedicinalProductPharmaceutical"] = "MedicinalProductPharmaceutical";
+    ImplementationGuideType["FamilyMemberHistory"] = "FamilyMemberHistory";
+    ImplementationGuideType["ServiceRequest"] = "ServiceRequest";
+    ImplementationGuideType["DetectedIssue"] = "DetectedIssue";
+    ImplementationGuideType["Device"] = "Device";
+    ImplementationGuideType["RequestGroup"] = "RequestGroup";
+    ImplementationGuideType["TestScript"] = "TestScript";
+    ImplementationGuideType["RiskEvidenceSynthesis"] = "RiskEvidenceSynthesis";
+    ImplementationGuideType["SupplyRequest"] = "SupplyRequest";
+    ImplementationGuideType["Task"] = "Task";
+    ImplementationGuideType["CommunicationRequest"] = "CommunicationRequest";
+    ImplementationGuideType["EnrollmentRequest"] = "EnrollmentRequest";
+    ImplementationGuideType["ChargeItemDefinition"] = "ChargeItemDefinition";
+    ImplementationGuideType["Substance"] = "Substance";
+    ImplementationGuideType["Provenance"] = "Provenance";
+    ImplementationGuideType["Consent"] = "Consent";
+    ImplementationGuideType["CarePlan"] = "CarePlan";
+    ImplementationGuideType["TestReport"] = "TestReport";
+    ImplementationGuideType["Observation"] = "Observation";
+    ImplementationGuideType["DocumentManifest"] = "DocumentManifest";
+})(ImplementationGuideType = exports.ImplementationGuideType || (exports.ImplementationGuideType = {}));
+/** apply | path-resource | path-pages | path-tx-cache | expansion-parameter | rule-broken-links | generate-xml | generate-json | generate-turtle | html-template */
+var ImplementationGuideCode;
+(function (ImplementationGuideCode) {
+    ImplementationGuideCode["RuleBrokenLinks"] = "rule-broken-links";
+    ImplementationGuideCode["GenerateJson"] = "generate-json";
+    ImplementationGuideCode["GenerateTurtle"] = "generate-turtle";
+    ImplementationGuideCode["PathResource"] = "path-resource";
+    ImplementationGuideCode["PathPages"] = "path-pages";
+    ImplementationGuideCode["GenerateXml"] = "generate-xml";
+    ImplementationGuideCode["PathTxCache"] = "path-tx-cache";
+    ImplementationGuideCode["ExpansionParameter"] = "expansion-parameter";
+    ImplementationGuideCode["Apply"] = "apply";
+    ImplementationGuideCode["HtmlTemplate"] = "html-template";
+})(ImplementationGuideCode = exports.ImplementationGuideCode || (exports.ImplementationGuideCode = {}));
+/** SPDX license code for this IG (or not-open-source) */
+var ImplementationGuideLicense;
+(function (ImplementationGuideLicense) {
+    ImplementationGuideLicense["CCBYNCSANum1.0"] = "CC-BY-NC-SA-1.0";
+    ImplementationGuideLicense["QPLNum1.0"] = "QPL-1.0";
+    ImplementationGuideLicense["WatcomNum1.0"] = "Watcom-1.0";
+    ImplementationGuideLicense["Noweb"] = "Noweb";
+    ImplementationGuideLicense["Multics"] = "Multics";
+    ImplementationGuideLicense["NPLNum1.0"] = "NPL-1.0";
+    ImplementationGuideLicense["PDDLNum1.0"] = "PDDL-1.0";
+    ImplementationGuideLicense["CNRIJython"] = "CNRI-Jython";
+    ImplementationGuideLicense["GFDLNum1.3Only"] = "GFDL-1.3-only";
+    ImplementationGuideLicense["Zlib"] = "Zlib";
+    ImplementationGuideLicense["SAXPD"] = "SAX-PD";
+    ImplementationGuideLicense["Afmparse"] = "Afmparse";
+    ImplementationGuideLicense["LGPLNum2.0Only"] = "LGPL-2.0-only";
+    ImplementationGuideLicense["HaskellReport"] = "HaskellReport";
+    ImplementationGuideLicense["CCBYNCNDNum3.0"] = "CC-BY-NC-ND-3.0";
+    ImplementationGuideLicense["ICU"] = "ICU";
+    ImplementationGuideLicense["CCBYNCSANum2.5"] = "CC-BY-NC-SA-2.5";
+    ImplementationGuideLicense["CECILLC"] = "CECILL-C";
+    ImplementationGuideLicense["BSLNum1.0"] = "BSL-1.0";
+    ImplementationGuideLicense["AdobeNum2006"] = "Adobe-2006";
+    ImplementationGuideLicense["OLDAPNum1.1"] = "OLDAP-1.1";
+    ImplementationGuideLicense["Curl"] = "curl";
+    ImplementationGuideLicense["GPLNum2.0OrLater"] = "GPL-2.0-or-later";
+    ImplementationGuideLicense["OLDAPNum2.4"] = "OLDAP-2.4";
+    ImplementationGuideLicense["MPLNum1.0"] = "MPL-1.0";
+    ImplementationGuideLicense["Num0BSD"] = "0BSD";
+    ImplementationGuideLicense["SISSL"] = "SISSL";
+    ImplementationGuideLicense["Plexus"] = "Plexus";
+    ImplementationGuideLicense["Barr"] = "Barr";
+    ImplementationGuideLicense["OFLNum1.0"] = "OFL-1.0";
+    ImplementationGuideLicense["Caldera"] = "Caldera";
+    ImplementationGuideLicense["NPOSLNum3.0"] = "NPOSL-3.0";
+    ImplementationGuideLicense["Xinetd"] = "xinetd";
+    ImplementationGuideLicense["OLDAPNum2.1"] = "OLDAP-2.1";
+    ImplementationGuideLicense["Xpp"] = "xpp";
+    ImplementationGuideLicense["CDDLNum1.1"] = "CDDL-1.1";
+    ImplementationGuideLicense["CCBYNDNum2.0"] = "CC-BY-ND-2.0";
+    ImplementationGuideLicense["OCLCNum2.0"] = "OCLC-2.0";
+    ImplementationGuideLicense["MITAdvertising"] = "MIT-advertising";
+    ImplementationGuideLicense["EUPLNum1.2"] = "EUPL-1.2";
+    ImplementationGuideLicense["SimPLNum2.0"] = "SimPL-2.0";
+    ImplementationGuideLicense["InterbaseNum1.0"] = "Interbase-1.0";
+    ImplementationGuideLicense["APAFML"] = "APAFML";
+    ImplementationGuideLicense["Qhull"] = "Qhull";
+    ImplementationGuideLicense["CCBYNCNum2.0"] = "CC-BY-NC-2.0";
+    ImplementationGuideLicense["Psutils"] = "psutils";
+    ImplementationGuideLicense["BSDNum3ClauseClear"] = "BSD-3-Clause-Clear";
+    ImplementationGuideLicense["CECILLB"] = "CECILL-B";
+    ImplementationGuideLicense["OFLNum1.1"] = "OFL-1.1";
+    ImplementationGuideLicense["OGTSL"] = "OGTSL";
+    ImplementationGuideLicense["OLDAPNum2.2"] = "OLDAP-2.2";
+    ImplementationGuideLicense["ErlPLNum1.1"] = "ErlPL-1.1";
+    ImplementationGuideLicense["SISSLNum1.2"] = "SISSL-1.2";
+    ImplementationGuideLicense["BSDNum2ClausePatent"] = "BSD-2-Clause-Patent";
+    ImplementationGuideLicense["MTLL"] = "MTLL";
+    ImplementationGuideLicense["NPLNum1.1"] = "NPL-1.1";
+    ImplementationGuideLicense["BSDNum3ClauseAttribution"] = "BSD-3-Clause-Attribution";
+    ImplementationGuideLicense["NCSA"] = "NCSA";
+    ImplementationGuideLicense["OpenSSL"] = "OpenSSL";
+    ImplementationGuideLicense["Giftware"] = "Giftware";
+    ImplementationGuideLicense["NLODNum1.0"] = "NLOD-1.0";
+    ImplementationGuideLicense["GSOAPNum1.3b"] = "gSOAP-1.3b";
+    ImplementationGuideLicense["TCL"] = "TCL";
+    ImplementationGuideLicense["XSkat"] = "XSkat";
+    ImplementationGuideLicense["AMDPLPA"] = "AMDPLPA";
+    ImplementationGuideLicense["CCBYNDNum1.0"] = "CC-BY-ND-1.0";
+    ImplementationGuideLicense["NLPL"] = "NLPL";
+    ImplementationGuideLicense["DOC"] = "DOC";
+    ImplementationGuideLicense["AML"] = "AML";
+    ImplementationGuideLicense["CPLNum1.0"] = "CPL-1.0";
+    ImplementationGuideLicense["ANTLRPD"] = "ANTLR-PD";
+    ImplementationGuideLicense["CCBYSANum2.5"] = "CC-BY-SA-2.5";
+    ImplementationGuideLicense["AFLNum2.1"] = "AFL-2.1";
+    ImplementationGuideLicense["RHeCosNum1.1"] = "RHeCos-1.1";
+    ImplementationGuideLicense["CCBYNCSANum3.0"] = "CC-BY-NC-SA-3.0";
+    ImplementationGuideLicense["APSLNum2.0"] = "APSL-2.0";
+    ImplementationGuideLicense["AAL"] = "AAL";
+    ImplementationGuideLicense["CCBYNCSANum2.0"] = "CC-BY-NC-SA-2.0";
+    ImplementationGuideLicense["SMLNJ"] = "SMLNJ";
+    ImplementationGuideLicense["CNRIPython"] = "CNRI-Python";
+    ImplementationGuideLicense["VSLNum1.0"] = "VSL-1.0";
+    ImplementationGuideLicense["OLDAPNum2.2.2"] = "OLDAP-2.2.2";
+    ImplementationGuideLicense["Beerware"] = "Beerware";
+    ImplementationGuideLicense["Bzip2Num1.0.6"] = "bzip2-1.0.6";
+    ImplementationGuideLicense["LGPLNum3.0OrLater"] = "LGPL-3.0-or-later";
+    ImplementationGuideLicense["YPLNum1.0"] = "YPL-1.0";
+    ImplementationGuideLicense["APLNum1.0"] = "APL-1.0";
+    ImplementationGuideLicense["GFDLNum1.2OrLater"] = "GFDL-1.2-or-later";
+    ImplementationGuideLicense["LiLiQPNum1.1"] = "LiLiQ-P-1.1";
+    ImplementationGuideLicense["FreeImage"] = "FreeImage";
+    ImplementationGuideLicense["CPOLNum1.02"] = "CPOL-1.02";
+    ImplementationGuideLicense["BitTorrentNum1.0"] = "BitTorrent-1.0";
+    ImplementationGuideLicense["BSDNum3ClauseNoNuclearWarranty"] = "BSD-3-Clause-No-Nuclear-Warranty";
+    ImplementationGuideLicense["Dotseqn"] = "Dotseqn";
+    ImplementationGuideLicense["ArtisticNum2.0"] = "Artistic-2.0";
+    ImplementationGuideLicense["NTP"] = "NTP";
+    ImplementationGuideLicense["Newsletr"] = "Newsletr";
+    ImplementationGuideLicense["RPLNum1.5"] = "RPL-1.5";
+    ImplementationGuideLicense["NRL"] = "NRL";
+    ImplementationGuideLicense["MSRL"] = "MS-RL";
+    ImplementationGuideLicense["CCBYNum2.5"] = "CC-BY-2.5";
+    ImplementationGuideLicense["AGPLNum3.0Only"] = "AGPL-3.0-only";
+    ImplementationGuideLicense["GFDLNum1.2Only"] = "GFDL-1.2-only";
+    ImplementationGuideLicense["MITNFA"] = "MITNFA";
+    ImplementationGuideLicense["BSDNum2ClauseNetBSD"] = "BSD-2-Clause-NetBSD";
+    ImplementationGuideLicense["FSFUL"] = "FSFUL";
+    ImplementationGuideLicense["CCBYNCNDNum4.0"] = "CC-BY-NC-ND-4.0";
+    ImplementationGuideLicense["Saxpath"] = "Saxpath";
+    ImplementationGuideLicense["RPLNum1.1"] = "RPL-1.1";
+    ImplementationGuideLicense["FrameworxNum1.0"] = "Frameworx-1.0";
+    ImplementationGuideLicense["OLDAPNum2.0"] = "OLDAP-2.0";
+    ImplementationGuideLicense["FSFAP"] = "FSFAP";
+    ImplementationGuideLicense["Leptonica"] = "Leptonica";
+    ImplementationGuideLicense["CATOSLNum1.1"] = "CATOSL-1.1";
+    ImplementationGuideLicense["Bzip2Num1.0.5"] = "bzip2-1.0.5";
+    ImplementationGuideLicense["BSDProtection"] = "BSD-Protection";
+    ImplementationGuideLicense["Xerox"] = "Xerox";
+    ImplementationGuideLicense["Imlib2"] = "Imlib2";
+    ImplementationGuideLicense["CCBYNDNum4.0"] = "CC-BY-ND-4.0";
+    ImplementationGuideLicense["Psfrag"] = "psfrag";
+    ImplementationGuideLicense["W3CNum20150513"] = "W3C-20150513";
+    ImplementationGuideLicense["EGenix"] = "eGenix";
+    ImplementationGuideLicense["LALNum1.3"] = "LAL-1.3";
+    ImplementationGuideLicense["EUPLNum1.0"] = "EUPL-1.0";
+    ImplementationGuideLicense["CCBYNCNum2.5"] = "CC-BY-NC-2.5";
+    ImplementationGuideLicense["GPLNum2.0Only"] = "GPL-2.0-only";
+    ImplementationGuideLicense["Fair"] = "Fair";
+    ImplementationGuideLicense["MITEnna"] = "MIT-enna";
+    ImplementationGuideLicense["BSDNum4Clause"] = "BSD-4-Clause";
+    ImplementationGuideLicense["RSCPL"] = "RSCPL";
+    ImplementationGuideLicense["ZendNum2.0"] = "Zend-2.0";
+    ImplementationGuideLicense["InfoZIP"] = "Info-ZIP";
+    ImplementationGuideLicense["CCBYNCNum1.0"] = "CC-BY-NC-1.0";
+    ImplementationGuideLicense["BSDNum2Clause"] = "BSD-2-Clause";
+    ImplementationGuideLicense["OLDAPNum2.7"] = "OLDAP-2.7";
+    ImplementationGuideLicense["ODbLNum1.0"] = "ODbL-1.0";
+    ImplementationGuideLicense["APSLNum1.0"] = "APSL-1.0";
+    ImplementationGuideLicense["ECLNum1.0"] = "ECL-1.0";
+    ImplementationGuideLicense["ApacheNum1.0"] = "Apache-1.0";
+    ImplementationGuideLicense["AGPLNum3.0OrLater"] = "AGPL-3.0-or-later";
+    ImplementationGuideLicense["Intel"] = "Intel";
+    ImplementationGuideLicense["ArtisticNum1.0Perl"] = "Artistic-1.0-Perl";
+    ImplementationGuideLicense["GFDLNum1.3OrLater"] = "GFDL-1.3-or-later";
+    ImplementationGuideLicense["GPLNum1.0Only"] = "GPL-1.0-only";
+    ImplementationGuideLicense["AMPAS"] = "AMPAS";
+    ImplementationGuideLicense["BSDNum4ClauseUC"] = "BSD-4-Clause-UC";
+    ImplementationGuideLicense["SGIBNum1.1"] = "SGI-B-1.1";
+    ImplementationGuideLicense["IntelACPI"] = "Intel-ACPI";
+    ImplementationGuideLicense["EPLNum2.0"] = "EPL-2.0";
+    ImplementationGuideLicense["Ruby"] = "Ruby";
+    ImplementationGuideLicense["Glulxe"] = "Glulxe";
+    ImplementationGuideLicense["Aladdin"] = "Aladdin";
+    ImplementationGuideLicense["Sendmail"] = "Sendmail";
+    ImplementationGuideLicense["LPLNum1.0"] = "LPL-1.0";
+    ImplementationGuideLicense["CPALNum1.0"] = "CPAL-1.0";
+    ImplementationGuideLicense["CECILLNum2.1"] = "CECILL-2.1";
+    ImplementationGuideLicense["ZPLNum2.1"] = "ZPL-2.1";
+    ImplementationGuideLicense["UPLNum1.0"] = "UPL-1.0";
+    ImplementationGuideLicense["LGPLNum2.1OrLater"] = "LGPL-2.1-or-later";
+    ImplementationGuideLicense["OLDAPNum2.8"] = "OLDAP-2.8";
+    ImplementationGuideLicense["OSETPLNum2.1"] = "OSET-PL-2.1";
+    ImplementationGuideLicense["EUDatagrid"] = "EUDatagrid";
+    ImplementationGuideLicense["RPSLNum1.0"] = "RPSL-1.0";
+    ImplementationGuideLicense["SpencerNum99"] = "Spencer-99";
+    ImplementationGuideLicense["OSLNum2.0"] = "OSL-2.0";
+    ImplementationGuideLicense["YPLNum1.1"] = "YPL-1.1";
+    ImplementationGuideLicense["MITCMU"] = "MIT-CMU";
+    ImplementationGuideLicense["TMate"] = "TMate";
+    ImplementationGuideLicense["IBMPibs"] = "IBM-pibs";
+    ImplementationGuideLicense["AFLNum2.0"] = "AFL-2.0";
+    ImplementationGuideLicense["UnicodeDFSNum2015"] = "Unicode-DFS-2015";
+    ImplementationGuideLicense["CNRIPythonGPLCompatible"] = "CNRI-Python-GPL-Compatible";
+    ImplementationGuideLicense["DSDP"] = "DSDP";
+    ImplementationGuideLicense["MPLNum2.0NoCopyleftException"] = "MPL-2.0-no-copyleft-exception";
+    ImplementationGuideLicense["W3C"] = "W3C";
+    ImplementationGuideLicense["OLDAPNum1.2"] = "OLDAP-1.2";
+    ImplementationGuideLicense["CDLASharingNum1.0"] = "CDLA-Sharing-1.0";
+    ImplementationGuideLicense["LiLiQRNum1.1"] = "LiLiQ-R-1.1";
+    ImplementationGuideLicense["ZPLNum1.1"] = "ZPL-1.1";
+    ImplementationGuideLicense["CC0Num1.0"] = "CC0-1.0";
+    ImplementationGuideLicense["SWL"] = "SWL";
+    ImplementationGuideLicense["PythonNum2.0"] = "Python-2.0";
+    ImplementationGuideLicense["OLDAPNum1.4"] = "OLDAP-1.4";
+    ImplementationGuideLicense["LPPLNum1.1"] = "LPPL-1.1";
+    ImplementationGuideLicense["LPPLNum1.3c"] = "LPPL-1.3c";
+    ImplementationGuideLicense["Unlicense"] = "Unlicense";
+    ImplementationGuideLicense["SpencerNum94"] = "Spencer-94";
+    ImplementationGuideLicense["Cube"] = "Cube";
+    ImplementationGuideLicense["ZlibAcknowledgement"] = "zlib-acknowledgement";
+    ImplementationGuideLicense["CondorNum1.1"] = "Condor-1.1";
+    ImplementationGuideLicense["SMPPL"] = "SMPPL";
+    ImplementationGuideLicense["Libtiff"] = "libtiff";
+    ImplementationGuideLicense["OML"] = "OML";
+    ImplementationGuideLicense["SugarCRMNum1.1.3"] = "SugarCRM-1.1.3";
+    ImplementationGuideLicense["CCBYSANum1.0"] = "CC-BY-SA-1.0";
+    ImplementationGuideLicense["BSDNum3ClauseNoNuclearLicenseNum2014"] = "BSD-3-Clause-No-Nuclear-License-2014";
+    ImplementationGuideLicense["VOSTROM"] = "VOSTROM";
+    ImplementationGuideLicense["CCBYSANum4.0"] = "CC-BY-SA-4.0";
+    ImplementationGuideLicense["AGPLNum1.0OrLater"] = "AGPL-1.0-or-later";
+    ImplementationGuideLicense["CCBYNDNum3.0"] = "CC-BY-ND-3.0";
+    ImplementationGuideLicense["ZimbraNum1.3"] = "Zimbra-1.3";
+    ImplementationGuideLicense["LGPLNum3.0Only"] = "LGPL-3.0-only";
+    ImplementationGuideLicense["JasPerNum2.0"] = "JasPer-2.0";
+    ImplementationGuideLicense["OLDAPNum2.5"] = "OLDAP-2.5";
+    ImplementationGuideLicense["CCBYNum4.0"] = "CC-BY-4.0";
+    ImplementationGuideLicense["ISC"] = "ISC";
+    ImplementationGuideLicense["ImageMagick"] = "ImageMagick";
+    ImplementationGuideLicense["MakeIndex"] = "MakeIndex";
+    ImplementationGuideLicense["JSON"] = "JSON";
+    ImplementationGuideLicense["CrystalStacker"] = "CrystalStacker";
+    ImplementationGuideLicense["IMatix"] = "iMatix";
+    ImplementationGuideLicense["AGPLNum1.0Only"] = "AGPL-1.0-only";
+    ImplementationGuideLicense["GPLNum3.0OrLater"] = "GPL-3.0-or-later";
+    ImplementationGuideLicense["Naumen"] = "Naumen";
+    ImplementationGuideLicense["NASANum1.3"] = "NASA-1.3";
+    ImplementationGuideLicense["GL2PS"] = "GL2PS";
+    ImplementationGuideLicense["CCBYNum1.0"] = "CC-BY-1.0";
+    ImplementationGuideLicense["CCBYNCNum4.0"] = "CC-BY-NC-4.0";
+    ImplementationGuideLicense["LPPLNum1.0"] = "LPPL-1.0";
+    ImplementationGuideLicense["OLDAPNum2.2.1"] = "OLDAP-2.2.1";
+    ImplementationGuideLicense["ArtisticNum1.0Cl8"] = "Artistic-1.0-cl8";
+    ImplementationGuideLicense["OLDAPNum2.0.1"] = "OLDAP-2.0.1";
+    ImplementationGuideLicense["SCEA"] = "SCEA";
+    ImplementationGuideLicense["MITFeh"] = "MIT-feh";
+    ImplementationGuideLicense["NetSNMP"] = "Net-SNMP";
+    ImplementationGuideLicense["LGPLLR"] = "LGPLLR";
+    ImplementationGuideLicense["BSDNum3ClauseNoNuclearLicense"] = "BSD-3-Clause-No-Nuclear-License";
+    ImplementationGuideLicense["CCBYSANum2.0"] = "CC-BY-SA-2.0";
+    ImplementationGuideLicense["Nokia"] = "Nokia";
+    ImplementationGuideLicense["SGIBNum2.0"] = "SGI-B-2.0";
+    ImplementationGuideLicense["UnicodeTOU"] = "Unicode-TOU";
+    ImplementationGuideLicense["RSAMD"] = "RSA-MD";
+    ImplementationGuideLicense["CCBYNDNum2.5"] = "CC-BY-ND-2.5";
+    ImplementationGuideLicense["GPLNum3.0Only"] = "GPL-3.0-only";
+    ImplementationGuideLicense["LGPLNum2.0OrLater"] = "LGPL-2.0-or-later";
+    ImplementationGuideLicense["IPA"] = "IPA";
+    ImplementationGuideLicense["GFDLNum1.1OrLater"] = "GFDL-1.1-or-later";
+    ImplementationGuideLicense["OLDAPNum2.3"] = "OLDAP-2.3";
+    ImplementationGuideLicense["Libpng"] = "Libpng";
+    ImplementationGuideLicense["BSDSourceCode"] = "BSD-Source-Code";
+    ImplementationGuideLicense["SNIA"] = "SNIA";
+    ImplementationGuideLicense["CCBYNCNum3.0"] = "CC-BY-NC-3.0";
+    ImplementationGuideLicense["Entessa"] = "Entessa";
+    ImplementationGuideLicense["NBPLNum1.0"] = "NBPL-1.0";
+    ImplementationGuideLicense["MITNum0"] = "MIT-0";
+    ImplementationGuideLicense["PHPNum3.0"] = "PHP-3.0";
+    ImplementationGuideLicense["DFSLNum1.0"] = "D-FSL-1.0";
+    ImplementationGuideLicense["GFDLNum1.1Only"] = "GFDL-1.1-only";
+    ImplementationGuideLicense["PHPNum3.01"] = "PHP-3.01";
+    ImplementationGuideLicense["ZimbraNum1.4"] = "Zimbra-1.4";
+    ImplementationGuideLicense["BSDNum2ClauseFreeBSD"] = "BSD-2-Clause-FreeBSD";
+    ImplementationGuideLicense["Motosoto"] = "Motosoto";
+    ImplementationGuideLicense["CDLAPermissiveNum1.0"] = "CDLA-Permissive-1.0";
+    ImplementationGuideLicense["Diffmark"] = "diffmark";
+    ImplementationGuideLicense["MPLNum1.1"] = "MPL-1.1";
+    ImplementationGuideLicense["CECILLNum2.0"] = "CECILL-2.0";
+    ImplementationGuideLicense["ApacheNum2.0"] = "Apache-2.0";
+    ImplementationGuideLicense["Dvipdfm"] = "dvipdfm";
+    ImplementationGuideLicense["CCBYNCSANum4.0"] = "CC-BY-NC-SA-4.0";
+    ImplementationGuideLicense["PostgreSQL"] = "PostgreSQL";
+    ImplementationGuideLicense["CCBYNCNDNum2.5"] = "CC-BY-NC-ND-2.5";
+    ImplementationGuideLicense["MSPL"] = "MS-PL";
+    ImplementationGuideLicense["BSDNum1Clause"] = "BSD-1-Clause";
+    ImplementationGuideLicense["OSLNum1.0"] = "OSL-1.0";
+    ImplementationGuideLicense["CUAOPLNum1.0"] = "CUA-OPL-1.0";
+    ImplementationGuideLicense["TCPWrappers"] = "TCP-wrappers";
+    ImplementationGuideLicense["Mup"] = "Mup";
+    ImplementationGuideLicense["APSLNum1.2"] = "APSL-1.2";
+    ImplementationGuideLicense["SGIBNum1.0"] = "SGI-B-1.0";
+    ImplementationGuideLicense["AFLNum1.1"] = "AFL-1.1";
+    ImplementationGuideLicense["OSLNum1.1"] = "OSL-1.1";
+    ImplementationGuideLicense["IJG"] = "IJG";
+    ImplementationGuideLicense["OCCTPL"] = "OCCT-PL";
+    ImplementationGuideLicense["MPLNum2.0"] = "MPL-2.0";
+    ImplementationGuideLicense["Mpich2"] = "mpich2";
+    ImplementationGuideLicense["CECILLNum1.1"] = "CECILL-1.1";
+    ImplementationGuideLicense["ECLNum2.0"] = "ECL-2.0";
+    ImplementationGuideLicense["BSDNum3ClauseLBNL"] = "BSD-3-Clause-LBNL";
+    ImplementationGuideLicense["TOSL"] = "TOSL";
+    ImplementationGuideLicense["Crossword"] = "Crossword";
+    ImplementationGuideLicense["CCBYNum2.0"] = "CC-BY-2.0";
+    ImplementationGuideLicense["AdobeGlyph"] = "Adobe-Glyph";
+    ImplementationGuideLicense["OSLNum3.0"] = "OSL-3.0";
+    ImplementationGuideLicense["Xnet"] = "Xnet";
+    ImplementationGuideLicense["ZPLNum2.0"] = "ZPL-2.0";
+    ImplementationGuideLicense["Eurosym"] = "Eurosym";
+    ImplementationGuideLicense["TORQUENum1.1"] = "TORQUE-1.1";
+    ImplementationGuideLicense["ClArtistic"] = "ClArtistic";
+    ImplementationGuideLicense["EUPLNum1.1"] = "EUPL-1.1";
+    ImplementationGuideLicense["MIT"] = "MIT";
+    ImplementationGuideLicense["LPLNum1.02"] = "LPL-1.02";
+    ImplementationGuideLicense["AFLNum1.2"] = "AFL-1.2";
+    ImplementationGuideLicense["NotOpenSource"] = "not-open-source";
+    ImplementationGuideLicense["UnicodeDFSNum2016"] = "Unicode-DFS-2016";
+    ImplementationGuideLicense["Latex2e"] = "Latex2e";
+    ImplementationGuideLicense["CCBYNCNDNum2.0"] = "CC-BY-NC-ND-2.0";
+    ImplementationGuideLicense["WTFPL"] = "WTFPL";
+    ImplementationGuideLicense["NetCDF"] = "NetCDF";
+    ImplementationGuideLicense["ApacheNum1.1"] = "Apache-1.1";
+    ImplementationGuideLicense["OSLNum2.1"] = "OSL-2.1";
+    ImplementationGuideLicense["EPLNum1.0"] = "EPL-1.0";
+    ImplementationGuideLicense["LPPLNum1.3a"] = "LPPL-1.3a";
+    ImplementationGuideLicense["Vim"] = "Vim";
+    ImplementationGuideLicense["X11"] = "X11";
+    ImplementationGuideLicense["W3CNum19980720"] = "W3C-19980720";
+    ImplementationGuideLicense["EFLNum2.0"] = "EFL-2.0";
+    ImplementationGuideLicense["LALNum1.2"] = "LAL-1.2";
+    ImplementationGuideLicense["OLDAPNum1.3"] = "OLDAP-1.3";
+    ImplementationGuideLicense["XFree86Num1.1"] = "XFree86-1.1";
+    ImplementationGuideLicense["CCBYNum3.0"] = "CC-BY-3.0";
+    ImplementationGuideLicense["LGPLNum2.1Only"] = "LGPL-2.1-only";
+    ImplementationGuideLicense["Wsuipa"] = "Wsuipa";
+    ImplementationGuideLicense["CCBYSANum3.0"] = "CC-BY-SA-3.0";
+    ImplementationGuideLicense["BSDNum3Clause"] = "BSD-3-Clause";
+    ImplementationGuideLicense["Borceux"] = "Borceux";
+    ImplementationGuideLicense["ArtisticNum1.0"] = "Artistic-1.0";
+    ImplementationGuideLicense["LinuxOpenIB"] = "Linux-OpenIB";
+    ImplementationGuideLicense["FSFULLR"] = "FSFULLR";
+    ImplementationGuideLicense["Abstyles"] = "Abstyles";
+    ImplementationGuideLicense["SPLNum1.0"] = "SPL-1.0";
+    ImplementationGuideLicense["CECILLNum1.0"] = "CECILL-1.0";
+    ImplementationGuideLicense["FTL"] = "FTL";
+    ImplementationGuideLicense["CDDLNum1.0"] = "CDDL-1.0";
+    ImplementationGuideLicense["OLDAPNum2.6"] = "OLDAP-2.6";
+    ImplementationGuideLicense["Glide"] = "Glide";
+    ImplementationGuideLicense["AFLNum3.0"] = "AFL-3.0";
+    ImplementationGuideLicense["Rdisc"] = "Rdisc";
+    ImplementationGuideLicense["CCBYNCNDNum1.0"] = "CC-BY-NC-ND-1.0";
+    ImplementationGuideLicense["NGPL"] = "NGPL";
+    ImplementationGuideLicense["EFLNum1.0"] = "EFL-1.0";
+    ImplementationGuideLicense["Bahyph"] = "Bahyph";
+    ImplementationGuideLicense["LiLiQRplusNum1.1"] = "LiLiQ-Rplus-1.1";
+    ImplementationGuideLicense["NOSL"] = "NOSL";
+    ImplementationGuideLicense["GPLNum1.0OrLater"] = "GPL-1.0-or-later";
+    ImplementationGuideLicense["ADSL"] = "ADSL";
+    ImplementationGuideLicense["APSLNum1.1"] = "APSL-1.1";
+    ImplementationGuideLicense["HPND"] = "HPND";
+    ImplementationGuideLicense["Zed"] = "Zed";
+    ImplementationGuideLicense["SpencerNum86"] = "Spencer-86";
+    ImplementationGuideLicense["BitTorrentNum1.1"] = "BitTorrent-1.1";
+    ImplementationGuideLicense["MirOS"] = "MirOS";
+    ImplementationGuideLicense["IPLNum1.0"] = "IPL-1.0";
+    ImplementationGuideLicense["OPLNum1.0"] = "OPL-1.0";
+    ImplementationGuideLicense["Gnuplot"] = "gnuplot";
+    ImplementationGuideLicense["Sleepycat"] = "Sleepycat";
+    ImplementationGuideLicense["LPPLNum1.2"] = "LPPL-1.2";
+})(ImplementationGuideLicense = exports.ImplementationGuideLicense || (exports.ImplementationGuideLicense = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/InsurancePlan.d.ts b/vendor/r4/types/hl7-fhir-r4-core/InsurancePlan.d.ts
index 0fc15ad..e42dd9d 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/InsurancePlan.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/InsurancePlan.d.ts
@@ -11,11 +11,11 @@ import { DomainResource } from "./DomainResource";
 import { Money } from "./Money";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Details of a Health Insurance product/plan provided by an organization. */
 export interface InsurancePlan extends DomainResource {
+    resourceType: 'InsurancePlan';
     /** Where product applies */
     coverageArea?: Array<Reference>;
     /** Official name */
@@ -28,14 +28,14 @@ export interface InsurancePlan extends DomainResource {
     /** Alternate names */
     alias?: Array<string>;
     /** draft | active | retired | unknown */
-    status?: code;
+    status?: `${InsurancePlanStatus}`;
     _name?: Element;
     /** Business Identifier for Product */
     identifier?: Array<Identifier>;
     /** Product administrator */
-    administeredBy?: Reference<"Organization">;
+    administeredBy?: Reference<'Organization'>;
     /** Plan issuer */
-    ownedBy?: Reference<"Organization">;
+    ownedBy?: Reference<'Organization'>;
     /** What networks are Included */
     network?: Array<Reference>;
     /** When the product is available */
@@ -48,22 +48,12 @@ export interface InsurancePlan extends DomainResource {
     /** Contact for the product */
     contact?: Array<InsurancePlanContact>;
 }
-/** Benefit limits */
-export interface InsurancePlanLimit extends BackboneElement {
-    /** Maximum value allowed */
-    value?: Quantity;
-    /** Benefit limit details */
-    code?: CodeableConcept;
-}
-/** List of benefits */
-export interface InsurancePlanBenefit extends BackboneElement {
-    /** Type of benefit */
-    type: CodeableConcept;
-    /** Referral requirements */
-    requirement?: string;
-    _requirement?: Element;
-    /** Benefit limits */
-    limit?: Array<InsurancePlanLimit>;
+/** Specific costs */
+export interface InsurancePlanSpecificCost extends BackboneElement {
+    /** General category of benefit */
+    category: CodeableConcept;
+    /** Benefits list */
+    benefit?: Array<InsurancePlanBenefit>;
 }
 /** Coverage details */
 export interface InsurancePlanCoverage extends BackboneElement {
@@ -87,23 +77,25 @@ export interface InsurancePlanGeneralCost extends BackboneElement {
     comment?: string;
     _comment?: Element;
 }
-/** List of the costs */
-export interface InsurancePlanCost extends BackboneElement {
-    /** Type of cost */
-    type: CodeableConcept;
-    /** in-network | out-of-network | other */
-    applicability?: CodeableConcept;
-    /** Additional information about the cost */
-    qualifiers?: Array<CodeableConcept>;
-    /** The actual cost value */
+/** in-network | out-of-network | other */
+export declare enum InsurancePlanApplicability {
+    InNetwork = "in-network",
+    Other = "other",
+    OutOfNetwork = "out-of-network"
+}
+/** Benefit limits */
+export interface InsurancePlanLimit extends BackboneElement {
+    /** Maximum value allowed */
     value?: Quantity;
+    /** Benefit limit details */
+    code?: CodeableConcept;
 }
-/** Specific costs */
-export interface InsurancePlanSpecificCost extends BackboneElement {
-    /** General category of benefit */
-    category: CodeableConcept;
-    /** Benefits list */
-    benefit?: Array<InsurancePlanBenefit>;
+/** draft | active | retired | unknown */
+export declare enum InsurancePlanStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
 }
 /** Plan details */
 export interface InsurancePlanPlan extends BackboneElement {
@@ -120,6 +112,27 @@ export interface InsurancePlanPlan extends BackboneElement {
     /** Specific costs */
     specificCost?: Array<InsurancePlanSpecificCost>;
 }
+/** List of benefits */
+export interface InsurancePlanBenefit extends BackboneElement {
+    /** Type of benefit */
+    type: CodeableConcept;
+    /** Referral requirements */
+    requirement?: string;
+    _requirement?: Element;
+    /** Benefit limits */
+    limit?: Array<InsurancePlanLimit>;
+}
+/** List of the costs */
+export interface InsurancePlanCost extends BackboneElement {
+    /** Type of cost */
+    type: CodeableConcept;
+    /** in-network | out-of-network | other */
+    applicability?: `${InsurancePlanApplicability}`;
+    /** Additional information about the cost */
+    qualifiers?: Array<CodeableConcept>;
+    /** The actual cost value */
+    value?: Quantity;
+}
 /** Contact for the product */
 export interface InsurancePlanContact extends BackboneElement {
     /** The type of contact */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/InsurancePlan.js b/vendor/r4/types/hl7-fhir-r4-core/InsurancePlan.js
index c8ad2e5..576fe1c 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/InsurancePlan.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/InsurancePlan.js
@@ -1,2 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsurancePlanStatus = exports.InsurancePlanApplicability = void 0;
+/** in-network | out-of-network | other */
+var InsurancePlanApplicability;
+(function (InsurancePlanApplicability) {
+    InsurancePlanApplicability["InNetwork"] = "in-network";
+    InsurancePlanApplicability["Other"] = "other";
+    InsurancePlanApplicability["OutOfNetwork"] = "out-of-network";
+})(InsurancePlanApplicability = exports.InsurancePlanApplicability || (exports.InsurancePlanApplicability = {}));
+/** draft | active | retired | unknown */
+var InsurancePlanStatus;
+(function (InsurancePlanStatus) {
+    InsurancePlanStatus["Active"] = "active";
+    InsurancePlanStatus["Draft"] = "draft";
+    InsurancePlanStatus["Retired"] = "retired";
+    InsurancePlanStatus["Unknown"] = "unknown";
+})(InsurancePlanStatus = exports.InsurancePlanStatus || (exports.InsurancePlanStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Invoice.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Invoice.d.ts
index 82a3ba6..546752c 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Invoice.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Invoice.d.ts
@@ -9,12 +9,12 @@ import { Money } from "./Money";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose. */
 export interface Invoice extends DomainResource {
+    resourceType: 'Invoice';
     /** Invoice date / posting date */
     date?: dateTime;
     /** Net total of this Invoice */
@@ -22,7 +22,7 @@ export interface Invoice extends DomainResource {
     _date?: Element;
     _status?: Element;
     /** Recipient of this invoice */
-    recipient?: Reference<"Patient" | "Organization" | "RelatedPerson">;
+    recipient?: Reference<'Patient' | 'Organization' | 'RelatedPerson'>;
     /** Components of Invoice total */
     totalPriceComponent?: Array<InvoiceLineItemPriceComponent>;
     /** Type of Invoice */
@@ -36,42 +36,59 @@ export interface Invoice extends DomainResource {
     /** Comments made about the invoice */
     note?: Array<Annotation>;
     /** Account that is being balanced */
-    account?: Reference<"Account">;
+    account?: Reference<'Account'>;
     /** draft | issued | balanced | cancelled | entered-in-error */
-    status: code;
+    status: `${InvoiceStatus}`;
     /** Line items of this Invoice */
     lineItem?: Array<InvoiceLineItem>;
     /** Business Identifier for item */
     identifier?: Array<Identifier>;
     /** Issuing Organization of Invoice */
-    issuer?: Reference<"Organization">;
+    issuer?: Reference<'Organization'>;
     /** Reason for cancellation of this Invoice */
     cancelledReason?: string;
     /** Payment details */
     paymentTerms?: markdown;
     /** Recipient(s) of goods and services */
-    subject?: Reference<"Patient" | "Group">;
+    subject?: Reference<'Patient' | 'Group'>;
 }
 /** Participant in creation of this Invoice */
 export interface InvoiceParticipant extends BackboneElement {
     /** Type of involvement in creation of this Invoice */
     role?: CodeableConcept;
     /** Individual who was involved */
-    actor: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    actor: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
+}
+/** draft | issued | balanced | cancelled | entered-in-error */
+export declare enum InvoiceStatus {
+    Balanced = "balanced",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    EnteredInError = "entered-in-error",
+    Issued = "issued"
 }
 /** Line items of this Invoice */
 export interface InvoiceLineItem extends BackboneElement {
     /** Sequence number of line item */
     sequence?: positiveInt;
     _sequence?: Element;
-    chargeItemReference: Reference<"ChargeItem">;
+    chargeItemReference: Reference<'ChargeItem'>;
     chargeItemCodeableConcept: CodeableConcept;
     priceComponent?: Array<InvoiceLineItemPriceComponent>;
 }
+/** base | surcharge | deduction | discount | tax | informational */
+export declare enum InvoiceLineItemPriceComponentType {
+    Base = "base",
+    Deduction = "deduction",
+    Discount = "discount",
+    Informational = "informational",
+    Surcharge = "surcharge",
+    Tax = "tax"
+}
 /** Components of total line item price */
 export interface InvoiceLineItemPriceComponent extends BackboneElement {
     /** base | surcharge | deduction | discount | tax | informational */
-    type: code;
+    type: `${InvoiceLineItemPriceComponentType}`;
     _type?: Element;
     /** Code identifying the specific component */
     code?: CodeableConcept;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Invoice.js b/vendor/r4/types/hl7-fhir-r4-core/Invoice.js
index c8ad2e5..72a53aa 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Invoice.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Invoice.js
@@ -1,2 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvoiceLineItemPriceComponentType = exports.InvoiceStatus = void 0;
+/** draft | issued | balanced | cancelled | entered-in-error */
+var InvoiceStatus;
+(function (InvoiceStatus) {
+    InvoiceStatus["Balanced"] = "balanced";
+    InvoiceStatus["Cancelled"] = "cancelled";
+    InvoiceStatus["Draft"] = "draft";
+    InvoiceStatus["EnteredInError"] = "entered-in-error";
+    InvoiceStatus["Issued"] = "issued";
+})(InvoiceStatus = exports.InvoiceStatus || (exports.InvoiceStatus = {}));
+/** base | surcharge | deduction | discount | tax | informational */
+var InvoiceLineItemPriceComponentType;
+(function (InvoiceLineItemPriceComponentType) {
+    InvoiceLineItemPriceComponentType["Base"] = "base";
+    InvoiceLineItemPriceComponentType["Deduction"] = "deduction";
+    InvoiceLineItemPriceComponentType["Discount"] = "discount";
+    InvoiceLineItemPriceComponentType["Informational"] = "informational";
+    InvoiceLineItemPriceComponentType["Surcharge"] = "surcharge";
+    InvoiceLineItemPriceComponentType["Tax"] = "tax";
+})(InvoiceLineItemPriceComponentType = exports.InvoiceLineItemPriceComponentType || (exports.InvoiceLineItemPriceComponentType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Library.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Library.d.ts
index 0d06784..df8d096 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Library.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Library.d.ts
@@ -15,10 +15,10 @@ import { markdown } from "./markdown";
 import { ParameterDefinition } from "./ParameterDefinition";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** The Library resource is a general-purpose container for knowledge asset definitions. It can be used to describe and expose existing knowledge assets such as logic libraries and information model descriptions, as well as to describe a collection of knowledge assets. */
 export interface Library extends DomainResource {
+    resourceType: 'Library';
     /** Natural language description of the library */
     description?: markdown;
     _usage?: Element;
@@ -66,7 +66,7 @@ export interface Library extends DomainResource {
     usage?: string;
     _lastReviewDate?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${LibraryStatus}`;
     /** Subordinate title of the library */
     subtitle?: string;
     _name?: Element;
@@ -90,10 +90,17 @@ export interface Library extends DomainResource {
     relatedArtifact?: Array<RelatedArtifact>;
     /** Contact details for the publisher */
     contact?: Array<ContactDetail>;
-    subjectReference?: Reference<"Group">;
+    subjectReference?: Reference<'Group'>;
     /** Parameters defined by the library */
     parameter?: Array<ParameterDefinition>;
     _url?: Element;
     /** When the library is expected to be used */
     effectivePeriod?: Period;
 }
+/** draft | active | retired | unknown */
+export declare enum LibraryStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Library.js b/vendor/r4/types/hl7-fhir-r4-core/Library.js
index c8ad2e5..669a72a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Library.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Library.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LibraryStatus = void 0;
+/** draft | active | retired | unknown */
+var LibraryStatus;
+(function (LibraryStatus) {
+    LibraryStatus["Active"] = "active";
+    LibraryStatus["Draft"] = "draft";
+    LibraryStatus["Retired"] = "retired";
+    LibraryStatus["Unknown"] = "unknown";
+})(LibraryStatus = exports.LibraryStatus || (exports.LibraryStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Linkage.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Linkage.d.ts
index 2f33e84..1b1c91e 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Linkage.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Linkage.d.ts
@@ -3,22 +3,28 @@ DON'T MODIFY MANUALLY */
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** Identifies two or more records (resource instances) that refer to the same real-world "occurrence". */
 export interface Linkage extends DomainResource {
+    resourceType: 'Linkage';
     /** Whether this linkage assertion is active or not */
     active?: boolean;
     _active?: Element;
     /** Who is responsible for linkages */
-    author?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    author?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Item to be linked */
     item: Array<LinkageItem>;
 }
+/** source | alternate | historical */
+export declare enum LinkageType {
+    Alternate = "alternate",
+    Historical = "historical",
+    Source = "source"
+}
 /** Item to be linked */
 export interface LinkageItem extends BackboneElement {
     /** source | alternate | historical */
-    type: code;
+    type: `${LinkageType}`;
     _type?: Element;
     /** Resource being linked */
     resource: Reference;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Linkage.js b/vendor/r4/types/hl7-fhir-r4-core/Linkage.js
index c8ad2e5..a413cdd 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Linkage.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Linkage.js
@@ -1,2 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkageType = void 0;
+/** source | alternate | historical */
+var LinkageType;
+(function (LinkageType) {
+    LinkageType["Alternate"] = "alternate";
+    LinkageType["Historical"] = "historical";
+    LinkageType["Source"] = "source";
+})(LinkageType = exports.LinkageType || (exports.LinkageType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/List.d.ts b/vendor/r4/types/hl7-fhir-r4-core/List.d.ts
index 7979f23..c1ff9ef 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/List.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/List.d.ts
@@ -6,23 +6,23 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A list is a curated collection of resources. */
 export interface List extends DomainResource {
+    resourceType: 'List';
     /** When the list was prepared */
     date?: dateTime;
     /** Context in which list created */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _date?: Element;
     /** What order the list has */
     orderedBy?: CodeableConcept;
     _status?: Element;
     /** working | snapshot | changes */
-    mode: code;
+    mode: `${ListMode}`;
     /** Who and/or what defined the list contents (aka Author) */
-    source?: Reference<"Patient" | "PractitionerRole" | "Device" | "Practitioner">;
+    source?: Reference<'Patient' | 'PractitionerRole' | 'Device' | 'Practitioner'>;
     /** Descriptive name for the list */
     title?: string;
     /** Comments about the list */
@@ -30,7 +30,7 @@ export interface List extends DomainResource {
     /** Why list is empty */
     emptyReason?: CodeableConcept;
     /** current | retired | entered-in-error */
-    status: code;
+    status: `${ListStatus}`;
     /** What the purpose of this list is */
     code?: CodeableConcept;
     /** Business identifier */
@@ -40,7 +40,19 @@ export interface List extends DomainResource {
     _title?: Element;
     _mode?: Element;
     /** If all resources have the same subject */
-    subject?: Reference<"Patient" | "Device" | "Location" | "Group">;
+    subject?: Reference<'Patient' | 'Device' | 'Location' | 'Group'>;
+}
+/** working | snapshot | changes */
+export declare enum ListMode {
+    Changes = "changes",
+    Snapshot = "snapshot",
+    Working = "working"
+}
+/** current | retired | entered-in-error */
+export declare enum ListStatus {
+    Current = "current",
+    EnteredInError = "entered-in-error",
+    Retired = "retired"
 }
 /** Entries in the list */
 export interface ListEntry extends BackboneElement {
diff --git a/vendor/r4/types/hl7-fhir-r4-core/List.js b/vendor/r4/types/hl7-fhir-r4-core/List.js
index c8ad2e5..28f3aa2 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/List.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/List.js
@@ -1,2 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListStatus = exports.ListMode = void 0;
+/** working | snapshot | changes */
+var ListMode;
+(function (ListMode) {
+    ListMode["Changes"] = "changes";
+    ListMode["Snapshot"] = "snapshot";
+    ListMode["Working"] = "working";
+})(ListMode = exports.ListMode || (exports.ListMode = {}));
+/** current | retired | entered-in-error */
+var ListStatus;
+(function (ListStatus) {
+    ListStatus["Current"] = "current";
+    ListStatus["EnteredInError"] = "entered-in-error";
+    ListStatus["Retired"] = "retired";
+})(ListStatus = exports.ListStatus || (exports.ListStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Location.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Location.d.ts
index 1ebb487..ecb31a0 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Location.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Location.d.ts
@@ -14,24 +14,25 @@ import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** Details and position information for a physical place where services are provided and resources and participants may be stored, found, contained, or accommodated. */
 export interface Location extends DomainResource {
+    resourceType: 'Location';
     /** Additional details about the location that could be displayed as further information to identify the location beyond its name */
     description?: string;
     /** Physical location */
     address?: Address;
     /** Organization responsible for provisioning and upkeep */
-    managingOrganization?: Reference<"Organization">;
+    managingOrganization?: Reference<'Organization'>;
     /** Name of the location as used by humans */
     name?: string;
     _status?: Element;
     /** instance | kind */
-    mode?: code;
+    mode?: `${LocationMode}`;
     /** Type of function performed */
     type?: Array<CodeableConcept>;
     _description?: Element;
     /** A list of alternate names that the location is known as, or was known as, in the past */
     alias?: Array<string>;
     /** active | suspended | inactive */
-    status?: code;
+    status?: `${LocationStatus}`;
     _name?: Element;
     _availabilityExceptions?: Element;
     /** Unique code or number identifying the location to its users */
@@ -47,7 +48,7 @@ export interface Location extends DomainResource {
     /** The operational status of the location (typically only for a bed/room) */
     operationalStatus?: Coding;
     /** Another Location this one is physically a part of */
-    partOf?: Reference<"Location">;
+    partOf?: Reference<'Location'>;
     _alias?: Array<Element>;
     _mode?: Element;
     /** Physical form of the location */
@@ -55,6 +56,17 @@ export interface Location extends DomainResource {
     /** Technical endpoints providing access to services operated for the location */
     endpoint?: Array<Reference>;
 }
+/** instance | kind */
+export declare enum LocationMode {
+    Instance = "instance",
+    Kind = "kind"
+}
+/** active | suspended | inactive */
+export declare enum LocationStatus {
+    Active = "active",
+    Inactive = "inactive",
+    Suspended = "suspended"
+}
 /** What days/times during a week is this location usually open */
 export interface LocationHoursOfOperation extends BackboneElement {
     /** mon | tue | wed | thu | fri | sat | sun */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Location.js b/vendor/r4/types/hl7-fhir-r4-core/Location.js
index c8ad2e5..15b3f81 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Location.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Location.js
@@ -1,2 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocationStatus = exports.LocationMode = void 0;
+/** instance | kind */
+var LocationMode;
+(function (LocationMode) {
+    LocationMode["Instance"] = "instance";
+    LocationMode["Kind"] = "kind";
+})(LocationMode = exports.LocationMode || (exports.LocationMode = {}));
+/** active | suspended | inactive */
+var LocationStatus;
+(function (LocationStatus) {
+    LocationStatus["Active"] = "active";
+    LocationStatus["Inactive"] = "inactive";
+    LocationStatus["Suspended"] = "suspended";
+})(LocationStatus = exports.LocationStatus || (exports.LocationStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Measure.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Measure.d.ts
index 3cdc3c6..98086ea 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Measure.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Measure.d.ts
@@ -14,11 +14,11 @@ import { date } from "./date";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** The Measure resource provides the definition of a quality measure. */
 export interface Measure extends DomainResource {
+    resourceType: 'Measure';
     /** Natural language description of the measure */
     description?: markdown;
     _riskAdjustment?: Element;
@@ -82,7 +82,7 @@ export interface Measure extends DomainResource {
     rationale?: markdown;
     _lastReviewDate?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${MeasureStatus}`;
     _rationale?: Element;
     /** Subordinate title of the measure */
     subtitle?: string;
@@ -112,9 +112,9 @@ export interface Measure extends DomainResource {
     relatedArtifact?: Array<RelatedArtifact>;
     /** Contact details for the publisher */
     contact?: Array<ContactDetail>;
-    subjectReference?: Reference<"Group">;
+    subjectReference?: Reference<'Group'>;
     /** increase | decrease */
-    improvementNotation?: CodeableConcept;
+    improvementNotation?: `${MeasureImprovementNotation}`;
     _url?: Element;
     _disclaimer?: Element;
     /** How is rate aggregation performed for this measure */
@@ -181,3 +181,15 @@ export interface MeasureSupplementalData extends BackboneElement {
     /** Expression describing additional data to be reported */
     criteria: Expression;
 }
+/** draft | active | retired | unknown */
+export declare enum MeasureStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** increase | decrease */
+export declare enum MeasureImprovementNotation {
+    Decrease = "decrease",
+    Increase = "increase"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Measure.js b/vendor/r4/types/hl7-fhir-r4-core/Measure.js
index c8ad2e5..e17ab02 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Measure.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Measure.js
@@ -1,2 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeasureImprovementNotation = exports.MeasureStatus = void 0;
+/** draft | active | retired | unknown */
+var MeasureStatus;
+(function (MeasureStatus) {
+    MeasureStatus["Active"] = "active";
+    MeasureStatus["Draft"] = "draft";
+    MeasureStatus["Retired"] = "retired";
+    MeasureStatus["Unknown"] = "unknown";
+})(MeasureStatus = exports.MeasureStatus || (exports.MeasureStatus = {}));
+/** increase | decrease */
+var MeasureImprovementNotation;
+(function (MeasureImprovementNotation) {
+    MeasureImprovementNotation["Decrease"] = "decrease";
+    MeasureImprovementNotation["Increase"] = "increase";
+})(MeasureImprovementNotation = exports.MeasureImprovementNotation || (exports.MeasureImprovementNotation = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MeasureReport.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MeasureReport.d.ts
index 9190bab..b64dbd0 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MeasureReport.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MeasureReport.d.ts
@@ -9,11 +9,11 @@ import { integer } from "./integer";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation. */
 export interface MeasureReport extends DomainResource {
+    resourceType: 'MeasureReport';
     /** What data was used to calculate the measure score */
     evaluatedResource?: Array<Reference>;
     _measure?: Element;
@@ -25,21 +25,21 @@ export interface MeasureReport extends DomainResource {
     _type?: Element;
     _status?: Element;
     /** individual | subject-list | summary | data-collection */
-    type: code;
+    type: `${MeasureReportType}`;
     /** What measure was calculated */
     measure: canonical;
     /** Who is reporting the data */
-    reporter?: Reference<"PractitionerRole" | "Organization" | "Location" | "Practitioner">;
+    reporter?: Reference<'PractitionerRole' | 'Organization' | 'Location' | 'Practitioner'>;
     /** complete | pending | error */
-    status: code;
+    status: `${MeasureReportStatus}`;
     /** Additional identifier for the MeasureReport */
     identifier?: Array<Identifier>;
     /** What period the report covers */
     period: Period;
     /** increase | decrease */
-    improvementNotation?: CodeableConcept;
+    improvementNotation?: `${MeasureReportImprovementNotation}`;
     /** What individual(s) the report is for */
-    subject?: Reference<"Patient" | "PractitionerRole" | "Device" | "Location" | "Practitioner" | "RelatedPerson" | "Group">;
+    subject?: Reference<'Patient' | 'PractitionerRole' | 'Device' | 'Location' | 'Practitioner' | 'RelatedPerson' | 'Group'>;
 }
 /** The populations in the group */
 export interface MeasureReportPopulation extends BackboneElement {
@@ -49,7 +49,7 @@ export interface MeasureReportPopulation extends BackboneElement {
     count?: integer;
     _count?: Element;
     /** For subject-list reports, the subject results in this population */
-    subjectResults?: Reference<"List">;
+    subjectResults?: Reference<'List'>;
 }
 /** Stratifier component values */
 export interface MeasureReportComponent extends BackboneElement {
@@ -87,3 +87,21 @@ export interface MeasureReportGroup extends BackboneElement {
     /** Stratification results */
     stratifier?: Array<MeasureReportStratifier>;
 }
+/** individual | subject-list | summary | data-collection */
+export declare enum MeasureReportType {
+    DataCollection = "data-collection",
+    Individual = "individual",
+    SubjectList = "subject-list",
+    Summary = "summary"
+}
+/** complete | pending | error */
+export declare enum MeasureReportStatus {
+    Complete = "complete",
+    Error = "error",
+    Pending = "pending"
+}
+/** increase | decrease */
+export declare enum MeasureReportImprovementNotation {
+    Decrease = "decrease",
+    Increase = "increase"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MeasureReport.js b/vendor/r4/types/hl7-fhir-r4-core/MeasureReport.js
index c8ad2e5..7b15ec3 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MeasureReport.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/MeasureReport.js
@@ -1,2 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeasureReportImprovementNotation = exports.MeasureReportStatus = exports.MeasureReportType = void 0;
+/** individual | subject-list | summary | data-collection */
+var MeasureReportType;
+(function (MeasureReportType) {
+    MeasureReportType["DataCollection"] = "data-collection";
+    MeasureReportType["Individual"] = "individual";
+    MeasureReportType["SubjectList"] = "subject-list";
+    MeasureReportType["Summary"] = "summary";
+})(MeasureReportType = exports.MeasureReportType || (exports.MeasureReportType = {}));
+/** complete | pending | error */
+var MeasureReportStatus;
+(function (MeasureReportStatus) {
+    MeasureReportStatus["Complete"] = "complete";
+    MeasureReportStatus["Error"] = "error";
+    MeasureReportStatus["Pending"] = "pending";
+})(MeasureReportStatus = exports.MeasureReportStatus || (exports.MeasureReportStatus = {}));
+/** increase | decrease */
+var MeasureReportImprovementNotation;
+(function (MeasureReportImprovementNotation) {
+    MeasureReportImprovementNotation["Decrease"] = "decrease";
+    MeasureReportImprovementNotation["Increase"] = "increase";
+})(MeasureReportImprovementNotation = exports.MeasureReportImprovementNotation || (exports.MeasureReportImprovementNotation = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Media.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Media.d.ts
index 092bbc3..2c99070 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Media.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Media.d.ts
@@ -10,18 +10,18 @@ import { DomainResource } from "./DomainResource";
 import { instant } from "./instant";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { decimal } from "./decimal";
 /** A photo, video, or audio recording acquired or used in healthcare. The actual content may be inline or provided by direct reference. */
 export interface Media extends DomainResource {
+    resourceType: 'Media';
     _issued?: Element;
     /** Name of the device/manufacturer */
     deviceName?: string;
     _width?: Element;
     _duration?: Element;
     /** Encounter associated with media */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     /** Actual Media - reference or data */
     content: Attachment;
     /** Number of frames if > 1 (photo) */
@@ -43,18 +43,18 @@ export interface Media extends DomainResource {
     _height?: Element;
     createdPeriod?: Period;
     /** preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown */
-    status: code;
+    status: `${MediaStatus}`;
     /** Identifier(s) for the image */
     identifier?: Array<Identifier>;
     /** The person who generated the image */
-    operator?: Reference<"CareTeam" | "Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    operator?: Reference<'CareTeam' | 'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** Observed body part */
     bodySite?: CodeableConcept;
     _createdDateTime?: Element;
     /** Date/Time this version was made available */
     issued?: instant;
     /** Observing Device */
-    device?: Reference<"Device" | "DeviceMetric">;
+    device?: Reference<'Device' | 'DeviceMetric'>;
     /** Procedure that caused this media to be created */
     basedOn?: Array<Reference>;
     _deviceName?: Element;
@@ -62,9 +62,20 @@ export interface Media extends DomainResource {
     partOf?: Array<Reference>;
     createdDateTime?: dateTime;
     /** Who/What this Media is a record of */
-    subject?: Reference<"Patient" | "PractitionerRole" | "Device" | "Location" | "Practitioner" | "Specimen" | "Group">;
+    subject?: Reference<'Patient' | 'PractitionerRole' | 'Device' | 'Location' | 'Practitioner' | 'Specimen' | 'Group'>;
     /** Imaging view, e.g. Lateral or Antero-posterior */
     view?: CodeableConcept;
     /** Height of the image in pixels (photo/video) */
     height?: positiveInt;
 }
+/** preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown */
+export declare enum MediaStatus {
+    Completed = "completed",
+    EnteredInError = "entered-in-error",
+    InProgress = "in-progress",
+    NotDone = "not-done",
+    OnHold = "on-hold",
+    Preparation = "preparation",
+    Stopped = "stopped",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Media.js b/vendor/r4/types/hl7-fhir-r4-core/Media.js
index c8ad2e5..570752f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Media.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Media.js
@@ -1,2 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaStatus = void 0;
+/** preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown */
+var MediaStatus;
+(function (MediaStatus) {
+    MediaStatus["Completed"] = "completed";
+    MediaStatus["EnteredInError"] = "entered-in-error";
+    MediaStatus["InProgress"] = "in-progress";
+    MediaStatus["NotDone"] = "not-done";
+    MediaStatus["OnHold"] = "on-hold";
+    MediaStatus["Preparation"] = "preparation";
+    MediaStatus["Stopped"] = "stopped";
+    MediaStatus["Unknown"] = "unknown";
+})(MediaStatus = exports.MediaStatus || (exports.MediaStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Medication.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Medication.d.ts
index c2c0c3e..f6b5a46 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Medication.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Medication.d.ts
@@ -6,11 +6,11 @@ import { DomainResource } from "./DomainResource";
 import { Ratio } from "./Ratio";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** This resource is primarily used for the identification and definition of a medication for the purposes of prescribing, dispensing, and administering a medication as well as for making statements about medication use. */
 export interface Medication extends DomainResource {
+    resourceType: 'Medication';
     /** Amount of drug in package */
     amount?: Ratio;
     _status?: Element;
@@ -19,13 +19,13 @@ export interface Medication extends DomainResource {
     /** Active or inactive ingredient */
     ingredient?: Array<MedicationIngredient>;
     /** active | inactive | entered-in-error */
-    status?: code;
+    status?: `${MedicationStatus}`;
     /** Codes that identify this medication */
     code?: CodeableConcept;
     /** Business identifier for this medication */
     identifier?: Array<Identifier>;
     /** Manufacturer of the item */
-    manufacturer?: Reference<"Organization">;
+    manufacturer?: Reference<'Organization'>;
     /** powder | tablets | capsule + */
     form?: CodeableConcept;
 }
@@ -41,10 +41,16 @@ export interface MedicationBatch extends BackboneElement {
 /** Active or inactive ingredient */
 export interface MedicationIngredient extends BackboneElement {
     itemCodeableConcept: CodeableConcept;
-    itemReference: Reference<"Medication" | "Substance">;
+    itemReference: Reference<'Medication' | 'Substance'>;
     /** Active ingredient indicator */
     isActive?: boolean;
     _isActive?: Element;
     /** Quantity of ingredient present */
     strength?: Ratio;
 }
+/** active | inactive | entered-in-error */
+export declare enum MedicationStatus {
+    Active = "active",
+    EnteredInError = "entered-in-error",
+    Inactive = "inactive"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Medication.js b/vendor/r4/types/hl7-fhir-r4-core/Medication.js
index c8ad2e5..8414717 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Medication.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Medication.js
@@ -1,2 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MedicationStatus = void 0;
+/** active | inactive | entered-in-error */
+var MedicationStatus;
+(function (MedicationStatus) {
+    MedicationStatus["Active"] = "active";
+    MedicationStatus["EnteredInError"] = "entered-in-error";
+    MedicationStatus["Inactive"] = "inactive";
+})(MedicationStatus = exports.MedicationStatus || (exports.MedicationStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicationAdministration.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicationAdministration.d.ts
index d1b0022..48be494 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicationAdministration.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicationAdministration.d.ts
@@ -11,15 +11,15 @@ import { DomainResource } from "./DomainResource";
 import { Ratio } from "./Ratio";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Describes the event of a patient consuming or otherwise being administered a medication.  This may be as simple as swallowing a tablet or it may be a long running infusion.  Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner. */
 export interface MedicationAdministration extends DomainResource {
+    resourceType: 'MedicationAdministration';
     /** Type of medication usage */
     category?: CodeableConcept;
     /** Request administration performed against */
-    request?: Reference<"MedicationRequest">;
+    request?: Reference<'MedicationRequest'>;
     _effectiveDateTime: Element;
     /** A list of events of interest in the lifecycle */
     eventHistory?: Array<Reference>;
@@ -40,18 +40,18 @@ export interface MedicationAdministration extends DomainResource {
     supportingInformation?: Array<Reference>;
     effectiveDateTime: dateTime;
     /** in-progress | not-done | on-hold | completed | entered-in-error | stopped | unknown */
-    status: code;
+    status: `${MedicationAdministrationStatus}`;
     /** External identifier */
     identifier?: Array<Identifier>;
     /** Encounter or Episode of Care administered as part of */
-    context?: Reference<"EpisodeOfCare" | "Encounter">;
+    context?: Reference<'EpisodeOfCare' | 'Encounter'>;
     /** Device used to administer */
     device?: Array<Reference>;
-    medicationReference: Reference<"Medication">;
+    medicationReference: Reference<'Medication'>;
     /** Part of referenced event */
     partOf?: Array<Reference>;
     /** Who received medication */
-    subject: Reference<"Patient" | "Group">;
+    subject: Reference<'Patient' | 'Group'>;
     /** Who performed the medication administration and what they did */
     performer?: Array<MedicationAdministrationPerformer>;
     effectivePeriod: Period;
@@ -74,10 +74,20 @@ export interface MedicationAdministrationDosage extends BackboneElement {
     /** Free text dosage instructions e.g. SIG */
     text?: string;
 }
+/** in-progress | not-done | on-hold | completed | entered-in-error | stopped | unknown */
+export declare enum MedicationAdministrationStatus {
+    Completed = "completed",
+    EnteredInError = "entered-in-error",
+    InProgress = "in-progress",
+    NotDone = "not-done",
+    OnHold = "on-hold",
+    Stopped = "stopped",
+    Unknown = "unknown"
+}
 /** Who performed the medication administration and what they did */
 export interface MedicationAdministrationPerformer extends BackboneElement {
     /** Type of performance */
     function?: CodeableConcept;
     /** Who performed the medication administration */
-    actor: Reference<"Patient" | "PractitionerRole" | "Device" | "Practitioner" | "RelatedPerson">;
+    actor: Reference<'Patient' | 'PractitionerRole' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicationAdministration.js b/vendor/r4/types/hl7-fhir-r4-core/MedicationAdministration.js
index c8ad2e5..4115d4f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicationAdministration.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicationAdministration.js
@@ -1,2 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MedicationAdministrationStatus = void 0;
+/** in-progress | not-done | on-hold | completed | entered-in-error | stopped | unknown */
+var MedicationAdministrationStatus;
+(function (MedicationAdministrationStatus) {
+    MedicationAdministrationStatus["Completed"] = "completed";
+    MedicationAdministrationStatus["EnteredInError"] = "entered-in-error";
+    MedicationAdministrationStatus["InProgress"] = "in-progress";
+    MedicationAdministrationStatus["NotDone"] = "not-done";
+    MedicationAdministrationStatus["OnHold"] = "on-hold";
+    MedicationAdministrationStatus["Stopped"] = "stopped";
+    MedicationAdministrationStatus["Unknown"] = "unknown";
+})(MedicationAdministrationStatus = exports.MedicationAdministrationStatus || (exports.MedicationAdministrationStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicationDispense.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicationDispense.d.ts
index b66c3b0..cab237c 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicationDispense.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicationDispense.d.ts
@@ -8,13 +8,13 @@ import { Dosage } from "./Dosage";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Indicates that a medication product is to be or has been dispensed for a named person/patient.  This includes a description of the medication product (supply) provided and the instructions for administering the medication.  The medication dispense is the result of a pharmacy system responding to a medication order. */
 export interface MedicationDispense extends DomainResource {
+    resourceType: 'MedicationDispense';
     _whenPrepared?: Element;
-    statusReasonReference?: Reference<"DetectedIssue">;
+    statusReasonReference?: Reference<'DetectedIssue'>;
     /** Type of medication dispense */
     category?: CodeableConcept;
     /** When product was given out */
@@ -37,7 +37,7 @@ export interface MedicationDispense extends DomainResource {
     /** Information that supports the dispensing of the medication */
     supportingInformation?: Array<Reference>;
     /** preparation | in-progress | cancelled | on-hold | completed | entered-in-error | stopped | declined | unknown */
-    status: code;
+    status: `${MedicationDispenseStatus}`;
     /** How the medication is to be used by the patient or administered by the caregiver */
     dosageInstruction?: Array<Dosage>;
     /** Amount of medication expressed as a timing amount */
@@ -45,23 +45,23 @@ export interface MedicationDispense extends DomainResource {
     /** External identifier */
     identifier?: Array<Identifier>;
     /** Encounter / Episode associated with event */
-    context?: Reference<"EpisodeOfCare" | "Encounter">;
-    medicationReference: Reference<"Medication">;
+    context?: Reference<'EpisodeOfCare' | 'Encounter'>;
+    medicationReference: Reference<'Medication'>;
     /** Amount dispensed */
     quantity?: SimpleQuantity;
     /** Event that dispense is part of */
     partOf?: Array<Reference>;
     _whenHandedOver?: Element;
     /** Where the dispense occurred */
-    location?: Reference<"Location">;
+    location?: Reference<'Location'>;
     /** Medication order that authorizes the dispense */
     authorizingPrescription?: Array<Reference>;
     /** Who collected the medication */
     receiver?: Array<Reference>;
     /** Who the dispense is for */
-    subject?: Reference<"Patient" | "Group">;
+    subject?: Reference<'Patient' | 'Group'>;
     /** Where the medication was sent */
-    destination?: Reference<"Location">;
+    destination?: Reference<'Location'>;
     /** Who performed event */
     performer?: Array<MedicationDispensePerformer>;
 }
@@ -77,10 +77,22 @@ export interface MedicationDispenseSubstitution extends BackboneElement {
     /** Who is responsible for the substitution */
     responsibleParty?: Array<Reference>;
 }
+/** preparation | in-progress | cancelled | on-hold | completed | entered-in-error | stopped | declined | unknown */
+export declare enum MedicationDispenseStatus {
+    Cancelled = "cancelled",
+    Preparation = "preparation",
+    Unknown = "unknown",
+    InProgress = "in-progress",
+    EnteredInError = "entered-in-error",
+    Declined = "declined",
+    Stopped = "stopped",
+    Completed = "completed",
+    OnHold = "on-hold"
+}
 /** Who performed event */
 export interface MedicationDispensePerformer extends BackboneElement {
     /** Who performed the dispense and what they did */
     function?: CodeableConcept;
     /** Individual who was performing */
-    actor: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    actor: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicationDispense.js b/vendor/r4/types/hl7-fhir-r4-core/MedicationDispense.js
index c8ad2e5..b30c256 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicationDispense.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicationDispense.js
@@ -1,2 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MedicationDispenseStatus = void 0;
+/** preparation | in-progress | cancelled | on-hold | completed | entered-in-error | stopped | declined | unknown */
+var MedicationDispenseStatus;
+(function (MedicationDispenseStatus) {
+    MedicationDispenseStatus["Cancelled"] = "cancelled";
+    MedicationDispenseStatus["Preparation"] = "preparation";
+    MedicationDispenseStatus["Unknown"] = "unknown";
+    MedicationDispenseStatus["InProgress"] = "in-progress";
+    MedicationDispenseStatus["EnteredInError"] = "entered-in-error";
+    MedicationDispenseStatus["Declined"] = "declined";
+    MedicationDispenseStatus["Stopped"] = "stopped";
+    MedicationDispenseStatus["Completed"] = "completed";
+    MedicationDispenseStatus["OnHold"] = "on-hold";
+})(MedicationDispenseStatus = exports.MedicationDispenseStatus || (exports.MedicationDispenseStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicationKnowledge.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicationKnowledge.d.ts
index 0691724..f99f7cb 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicationKnowledge.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicationKnowledge.d.ts
@@ -12,10 +12,10 @@ import { markdown } from "./markdown";
 import { base64Binary } from "./base64Binary";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** Information about a medication that is used to support knowledge. */
 export interface MedicationKnowledge extends DomainResource {
+    resourceType: 'MedicationKnowledge';
     /** The instructions for preparing the medication */
     preparationInstruction?: markdown;
     /** Amount of drug in package */
@@ -50,7 +50,7 @@ export interface MedicationKnowledge extends DomainResource {
     /** Potential clinical issue with or between medication(s) */
     contraindication?: Array<Reference>;
     /** active | inactive | entered-in-error */
-    status?: code;
+    status?: `${MedicationKnowledgeStatus}`;
     /** Category of the medication or product */
     productType?: Array<CodeableConcept>;
     /** Additional names for a medication */
@@ -60,7 +60,7 @@ export interface MedicationKnowledge extends DomainResource {
     /** Guidelines for administration of the medication */
     administrationGuidelines?: Array<MedicationKnowledgeAdministrationGuidelines>;
     /** Manufacturer of the item */
-    manufacturer?: Reference<"Organization">;
+    manufacturer?: Reference<'Organization'>;
     /** The pricing of the medication */
     cost?: Array<MedicationKnowledgeCost>;
 }
@@ -82,7 +82,7 @@ export interface MedicationKnowledgeSchedule extends BackboneElement {
 /** Active or inactive ingredient */
 export interface MedicationKnowledgeIngredient extends BackboneElement {
     itemCodeableConcept: CodeableConcept;
-    itemReference: Reference<"Substance">;
+    itemReference: Reference<'Substance'>;
     /** Active ingredient indicator */
     isActive?: boolean;
     _isActive?: Element;
@@ -113,7 +113,7 @@ export interface MedicationKnowledgeMonograph extends BackboneElement {
     /** The category of medication document */
     type?: CodeableConcept;
     /** Associated documentation about the medication */
-    source?: Reference<"Media" | "DocumentReference">;
+    source?: Reference<'Media' | 'DocumentReference'>;
 }
 /** Associated or related medication information */
 export interface MedicationKnowledgeRelatedMedicationKnowledge extends BackboneElement {
@@ -172,14 +172,14 @@ export interface MedicationKnowledgeAdministrationGuidelines extends BackboneEle
     /** Dosage for the medication for the specific guidelines */
     dosage?: Array<MedicationKnowledgeDosage>;
     indicationCodeableConcept?: CodeableConcept;
-    indicationReference?: Reference<"ObservationDefinition">;
+    indicationReference?: Reference<'ObservationDefinition'>;
     /** Characteristics of the patient that are relevant to the administration guidelines */
     patientCharacteristics?: Array<MedicationKnowledgePatientCharacteristics>;
 }
 /** Regulatory information about a medication */
 export interface MedicationKnowledgeRegulatory extends BackboneElement {
     /** Specifies the authority of the regulation */
-    regulatoryAuthority: Reference<"Organization">;
+    regulatoryAuthority: Reference<'Organization'>;
     /** Specifies if changes are allowed when dispensing a medication from a regulatory perspective */
     substitution?: Array<MedicationKnowledgeSubstitution>;
     /** Specifies the schedule of a medication in jurisdiction */
@@ -195,3 +195,9 @@ export interface MedicationKnowledgePatientCharacteristics extends BackboneEleme
     value?: Array<string>;
     _value?: Array<Element>;
 }
+/** active | inactive | entered-in-error */
+export declare enum MedicationKnowledgeStatus {
+    Active = "active",
+    EnteredInError = "entered-in-error",
+    Inactive = "inactive"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicationKnowledge.js b/vendor/r4/types/hl7-fhir-r4-core/MedicationKnowledge.js
index c8ad2e5..2214a86 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicationKnowledge.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicationKnowledge.js
@@ -1,2 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MedicationKnowledgeStatus = void 0;
+/** active | inactive | entered-in-error */
+var MedicationKnowledgeStatus;
+(function (MedicationKnowledgeStatus) {
+    MedicationKnowledgeStatus["Active"] = "active";
+    MedicationKnowledgeStatus["EnteredInError"] = "entered-in-error";
+    MedicationKnowledgeStatus["Inactive"] = "inactive";
+})(MedicationKnowledgeStatus = exports.MedicationKnowledgeStatus || (exports.MedicationKnowledgeStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicationRequest.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicationRequest.d.ts
index 3ddcd09..6862e20 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicationRequest.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicationRequest.d.ts
@@ -13,11 +13,11 @@ import { Duration } from "./Duration";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called "MedicationRequest" rather than "MedicationPrescription" or "MedicationOrder" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns. */
 export interface MedicationRequest extends DomainResource {
+    resourceType: 'MedicationRequest';
     /** Desired kind of performer of the medication administration */
     performerType?: CodeableConcept;
     /** Type of medication usage */
@@ -36,7 +36,7 @@ export interface MedicationRequest extends DomainResource {
     /** Clinical Issue with action */
     detectedIssue?: Array<Reference>;
     /** Encounter created as part of encounter/admission/stay */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _doNotPerform?: Element;
     /** Medication supply authorization */
     dispenseRequest?: MedicationRequestDispenseRequest;
@@ -54,39 +54,39 @@ export interface MedicationRequest extends DomainResource {
     _reportedBoolean?: Element;
     _intent?: Element;
     /** Who/What requested the Request */
-    requester?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    requester?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** Information to support ordering of the medication */
     supportingInformation?: Array<Reference>;
-    reportedReference?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Practitioner" | "RelatedPerson">;
+    reportedReference?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Practitioner' | 'RelatedPerson'>;
     /** routine | urgent | asap | stat */
-    priority?: code;
+    priority?: `${MedicationRequestPriority}`;
     /** active | on-hold | cancelled | completed | entered-in-error | stopped | draft | unknown */
-    status: code;
+    status: `${MedicationRequestStatus}`;
     /** How the medication should be taken */
     dosageInstruction?: Array<Dosage>;
     /** Composite request this is part of */
     groupIdentifier?: Identifier;
     /** Person who entered the request */
-    recorder?: Reference<"PractitionerRole" | "Practitioner">;
+    recorder?: Reference<'PractitionerRole' | 'Practitioner'>;
     reportedBoolean?: boolean;
     /** External ids for this request */
     identifier?: Array<Identifier>;
     /** True if request is prohibiting action */
     doNotPerform?: boolean;
     /** proposal | plan | order | original-order | reflex-order | filler-order | instance-order | option */
-    intent: code;
+    intent: `${MedicationRequestIntent}`;
     /** What request fulfills */
     basedOn?: Array<Reference>;
     /** An order/prescription that is being replaced */
-    priorPrescription?: Reference<"MedicationRequest">;
-    medicationReference: Reference<"Medication">;
+    priorPrescription?: Reference<'MedicationRequest'>;
+    medicationReference: Reference<'Medication'>;
     /** Overall pattern of medication administration */
     courseOfTherapyType?: CodeableConcept;
     _instantiatesCanonical?: Array<Element>;
     /** Who or group medication request is for */
-    subject: Reference<"Patient" | "Group">;
+    subject: Reference<'Patient' | 'Group'>;
     /** Intended performer of administration */
-    performer?: Reference<"CareTeam" | "Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    performer?: Reference<'CareTeam' | 'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** Condition or observation that supports why the prescription is being written */
     reasonReference?: Array<Reference>;
     _instantiatesUri?: Array<Element>;
@@ -122,5 +122,34 @@ export interface MedicationRequestDispenseRequest extends BackboneElement {
     /** Number of days supply per dispense */
     expectedSupplyDuration?: Duration;
     /** Intended dispenser */
-    performer?: Reference<"Organization">;
+    performer?: Reference<'Organization'>;
+}
+/** routine | urgent | asap | stat */
+export declare enum MedicationRequestPriority {
+    Asap = "asap",
+    Routine = "routine",
+    Stat = "stat",
+    Urgent = "urgent"
+}
+/** active | on-hold | cancelled | completed | entered-in-error | stopped | draft | unknown */
+export declare enum MedicationRequestStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Completed = "completed",
+    Draft = "draft",
+    EnteredInError = "entered-in-error",
+    OnHold = "on-hold",
+    Stopped = "stopped",
+    Unknown = "unknown"
+}
+/** proposal | plan | order | original-order | reflex-order | filler-order | instance-order | option */
+export declare enum MedicationRequestIntent {
+    FillerOrder = "filler-order",
+    InstanceOrder = "instance-order",
+    Option = "option",
+    Order = "order",
+    OriginalOrder = "original-order",
+    Plan = "plan",
+    Proposal = "proposal",
+    ReflexOrder = "reflex-order"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicationRequest.js b/vendor/r4/types/hl7-fhir-r4-core/MedicationRequest.js
index c8ad2e5..624ce57 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicationRequest.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicationRequest.js
@@ -1,2 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MedicationRequestIntent = exports.MedicationRequestStatus = exports.MedicationRequestPriority = void 0;
+/** routine | urgent | asap | stat */
+var MedicationRequestPriority;
+(function (MedicationRequestPriority) {
+    MedicationRequestPriority["Asap"] = "asap";
+    MedicationRequestPriority["Routine"] = "routine";
+    MedicationRequestPriority["Stat"] = "stat";
+    MedicationRequestPriority["Urgent"] = "urgent";
+})(MedicationRequestPriority = exports.MedicationRequestPriority || (exports.MedicationRequestPriority = {}));
+/** active | on-hold | cancelled | completed | entered-in-error | stopped | draft | unknown */
+var MedicationRequestStatus;
+(function (MedicationRequestStatus) {
+    MedicationRequestStatus["Active"] = "active";
+    MedicationRequestStatus["Cancelled"] = "cancelled";
+    MedicationRequestStatus["Completed"] = "completed";
+    MedicationRequestStatus["Draft"] = "draft";
+    MedicationRequestStatus["EnteredInError"] = "entered-in-error";
+    MedicationRequestStatus["OnHold"] = "on-hold";
+    MedicationRequestStatus["Stopped"] = "stopped";
+    MedicationRequestStatus["Unknown"] = "unknown";
+})(MedicationRequestStatus = exports.MedicationRequestStatus || (exports.MedicationRequestStatus = {}));
+/** proposal | plan | order | original-order | reflex-order | filler-order | instance-order | option */
+var MedicationRequestIntent;
+(function (MedicationRequestIntent) {
+    MedicationRequestIntent["FillerOrder"] = "filler-order";
+    MedicationRequestIntent["InstanceOrder"] = "instance-order";
+    MedicationRequestIntent["Option"] = "option";
+    MedicationRequestIntent["Order"] = "order";
+    MedicationRequestIntent["OriginalOrder"] = "original-order";
+    MedicationRequestIntent["Plan"] = "plan";
+    MedicationRequestIntent["Proposal"] = "proposal";
+    MedicationRequestIntent["ReflexOrder"] = "reflex-order";
+})(MedicationRequestIntent = exports.MedicationRequestIntent || (exports.MedicationRequestIntent = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicationStatement.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicationStatement.d.ts
index db4a8e9..e198dda 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicationStatement.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicationStatement.d.ts
@@ -8,12 +8,12 @@ import { Dosage } from "./Dosage";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** A record of a medication that is being consumed by a patient.   A MedicationStatement may indicate that the patient may be taking the medication now or has taken the medication in the past or will be taking the medication in the future.  The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician.  A common scenario where this information is captured is during the history taking process during a patient visit or stay.   The medication information may come from sources such as the patient's memory, from a prescription bottle,  or from a list of medications the patient, clinician or other party maintains.
 
 The primary difference between a medication statement and a medication administration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication.  A medication statement is often, if not always, less specific.  There is no required date/time when the medication was administered, in fact we only know that a source has reported the patient is taking this medication, where details such as time, quantity, or rate or even medication product may be incomplete or missing or less precise.  As stated earlier, the medication statement information may come from the patient's memory, from a prescription bottle or from a list of medications the patient, clinician or other party maintains.  Medication administration is more formal and is not missing detailed information. */
 export interface MedicationStatement extends DomainResource {
+    resourceType: 'MedicationStatement';
     /** Type of medication usage */
     category?: CodeableConcept;
     _effectiveDateTime?: Element;
@@ -31,24 +31,35 @@ export interface MedicationStatement extends DomainResource {
     note?: Array<Annotation>;
     effectiveDateTime?: dateTime;
     /** active | completed | entered-in-error | intended | stopped | on-hold | unknown | not-taken */
-    status: code;
+    status: `${MedicationStatementStatus}`;
     _dateAsserted?: Element;
     /** External identifier */
     identifier?: Array<Identifier>;
     /** Encounter / Episode associated with MedicationStatement */
-    context?: Reference<"EpisodeOfCare" | "Encounter">;
+    context?: Reference<'EpisodeOfCare' | 'Encounter'>;
     /** When the statement was asserted? */
     dateAsserted?: dateTime;
     /** Fulfils plan, proposal or order */
     basedOn?: Array<Reference>;
-    medicationReference: Reference<"Medication">;
+    medicationReference: Reference<'Medication'>;
     /** Part of referenced event */
     partOf?: Array<Reference>;
     /** Person or organization that provided the information about the taking of this medication */
-    informationSource?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Practitioner" | "RelatedPerson">;
+    informationSource?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Practitioner' | 'RelatedPerson'>;
     /** Who is/was taking  the medication */
-    subject: Reference<"Patient" | "Group">;
+    subject: Reference<'Patient' | 'Group'>;
     effectivePeriod?: Period;
     /** Condition or observation that supports why the medication is being/was taken */
     reasonReference?: Array<Reference>;
 }
+/** active | completed | entered-in-error | intended | stopped | on-hold | unknown | not-taken */
+export declare enum MedicationStatementStatus {
+    Active = "active",
+    Completed = "completed",
+    EnteredInError = "entered-in-error",
+    Intended = "intended",
+    NotTaken = "not-taken",
+    OnHold = "on-hold",
+    Stopped = "stopped",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicationStatement.js b/vendor/r4/types/hl7-fhir-r4-core/MedicationStatement.js
index c8ad2e5..7bf7a0f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicationStatement.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicationStatement.js
@@ -1,2 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MedicationStatementStatus = void 0;
+/** active | completed | entered-in-error | intended | stopped | on-hold | unknown | not-taken */
+var MedicationStatementStatus;
+(function (MedicationStatementStatus) {
+    MedicationStatementStatus["Active"] = "active";
+    MedicationStatementStatus["Completed"] = "completed";
+    MedicationStatementStatus["EnteredInError"] = "entered-in-error";
+    MedicationStatementStatus["Intended"] = "intended";
+    MedicationStatementStatus["NotTaken"] = "not-taken";
+    MedicationStatementStatus["OnHold"] = "on-hold";
+    MedicationStatementStatus["Stopped"] = "stopped";
+    MedicationStatementStatus["Unknown"] = "unknown";
+})(MedicationStatementStatus = exports.MedicationStatementStatus || (exports.MedicationStatementStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProduct.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProduct.d.ts
index 1dd4f77..d00fa4f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProduct.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProduct.d.ts
@@ -11,6 +11,7 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use). */
 export interface MedicinalProduct extends DomainResource {
+    resourceType: 'MedicinalProduct';
     /** Whether the Medicinal Product is subject to additional monitoring for regulatory reasons */
     additionalMonitoringIndicator?: CodeableConcept;
     /** An operation applied to the product, for manufacturing or adminsitrative purpose */
@@ -67,7 +68,7 @@ export interface MedicinalProductManufacturingBusinessOperation extends Backbone
     /** The manufacturer or establishment associated with the process */
     manufacturer?: Array<Reference>;
     /** A regulator which oversees the operation */
-    regulator?: Reference<"Organization">;
+    regulator?: Reference<'Organization'>;
 }
 /** Coding words or phrases of the name */
 export interface MedicinalProductNamePart extends BackboneElement {
@@ -112,5 +113,5 @@ export interface MedicinalProductSpecialDesignation extends BackboneElement {
     /** Identifier for the designation, or procedure number */
     identifier?: Array<Identifier>;
     indicationCodeableConcept?: CodeableConcept;
-    indicationReference?: Reference<"MedicinalProductIndication">;
+    indicationReference?: Reference<'MedicinalProductIndication'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductAuthorization.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductAuthorization.d.ts
index e0a920f..ebb29aa 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductAuthorization.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductAuthorization.d.ts
@@ -10,6 +10,7 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** The regulatory authorization of a medicinal product. */
 export interface MedicinalProductAuthorization extends DomainResource {
+    resourceType: 'MedicinalProductAuthorization';
     /** A period of time after authorization before generic product applicatiosn can be submitted */
     dataExclusivityPeriod?: Period;
     /** The date when a suspended the marketing or the marketing authorization of the product is anticipated to be restored */
@@ -24,7 +25,7 @@ export interface MedicinalProductAuthorization extends DomainResource {
     /** The beginning of the time period in which the marketing authorization is in the specific status shall be specified A complete date consisting of day, month and year shall be specified using the ISO 8601 date format */
     validityPeriod?: Period;
     /** Medicines Regulatory Agency */
-    regulator?: Reference<"Organization">;
+    regulator?: Reference<'Organization'>;
     /** The status of the marketing authorization */
     status?: CodeableConcept;
     /** Business identifier for the marketing authorization, as assigned by a regulator */
@@ -37,13 +38,13 @@ export interface MedicinalProductAuthorization extends DomainResource {
     /** Date of first marketing authorization for a company's new medicinal product in any country in the World */
     internationalBirthDate?: dateTime;
     /** Marketing Authorization Holder */
-    holder?: Reference<"Organization">;
+    holder?: Reference<'Organization'>;
     _restoreDate?: Element;
     _dateOfFirstAuthorization?: Element;
     /** The country in which the marketing authorization has been granted */
     country?: Array<CodeableConcept>;
     /** The medicinal product that is being authorized */
-    subject?: Reference<"MedicinalProductPackaged" | "MedicinalProduct">;
+    subject?: Reference<'MedicinalProductPackaged' | 'MedicinalProduct'>;
     _statusDate?: Element;
 }
 /** Authorization in areas within a country */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductContraindication.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductContraindication.d.ts
index 1ea1cb2..c91e53b 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductContraindication.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductContraindication.d.ts
@@ -7,6 +7,7 @@ import { Reference } from "./Reference";
 import { BackboneElement } from "./BackboneElement";
 /** The clinical particulars - indications, contraindications etc. of a medicinal product, including for regulatory purposes. */
 export interface MedicinalProductContraindication extends DomainResource {
+    resourceType: 'MedicinalProductContraindication';
     /** The medication for which this is an indication */
     subject?: Array<Reference>;
     /** The disease, symptom or procedure for the contraindication */
@@ -27,5 +28,5 @@ export interface MedicinalProductContraindicationOtherTherapy extends BackboneEl
     /** The type of relationship between the medicinal product indication or contraindication and another therapy */
     therapyRelationshipType: CodeableConcept;
     medicationCodeableConcept: CodeableConcept;
-    medicationReference: Reference<"Medication" | "SubstanceSpecification" | "Substance" | "MedicinalProduct">;
+    medicationReference: Reference<'Medication' | 'SubstanceSpecification' | 'Substance' | 'MedicinalProduct'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductIndication.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductIndication.d.ts
index 623dde0..476d2a0 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductIndication.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductIndication.d.ts
@@ -8,6 +8,7 @@ import { Reference } from "./Reference";
 import { BackboneElement } from "./BackboneElement";
 /** Indication for the Medicinal Product. */
 export interface MedicinalProductIndication extends DomainResource {
+    resourceType: 'MedicinalProductIndication';
     /** The disease, symptom or procedure that is the indication for treatment */
     diseaseSymptomProcedure?: CodeableConcept;
     /** Describe the undesirable effects of the medicinal product */
@@ -32,5 +33,5 @@ export interface MedicinalProductIndicationOtherTherapy extends BackboneElement
     /** The type of relationship between the medicinal product indication or contraindication and another therapy */
     therapyRelationshipType: CodeableConcept;
     medicationCodeableConcept: CodeableConcept;
-    medicationReference: Reference<"Medication" | "SubstanceSpecification" | "Substance" | "MedicinalProduct">;
+    medicationReference: Reference<'Medication' | 'SubstanceSpecification' | 'Substance' | 'MedicinalProduct'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductIngredient.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductIngredient.d.ts
index f8e09b8..ec1023f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductIngredient.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductIngredient.d.ts
@@ -9,6 +9,7 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** An ingredient of a manufactured item or pharmaceutical product. */
 export interface MedicinalProductIngredient extends DomainResource {
+    resourceType: 'MedicinalProductIngredient';
     /** Identifier for the ingredient */
     identifier?: Identifier;
     /** Ingredient role e.g. Active ingredient, excipient */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductInteraction.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductInteraction.d.ts
index 0982724..9e3d99f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductInteraction.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductInteraction.d.ts
@@ -7,6 +7,7 @@ import { Reference } from "./Reference";
 import { BackboneElement } from "./BackboneElement";
 /** The interactions of the medicinal product with other medicinal products, or other forms of interactions. */
 export interface MedicinalProductInteraction extends DomainResource {
+    resourceType: 'MedicinalProductInteraction';
     /** The medication for which this is a described interaction */
     subject?: Array<Reference>;
     /** The interaction described */
@@ -25,6 +26,6 @@ export interface MedicinalProductInteraction extends DomainResource {
 }
 /** The specific medication, food or laboratory test that interacts */
 export interface MedicinalProductInteractionInteractant extends BackboneElement {
-    itemReference: Reference<"Medication" | "Substance" | "MedicinalProduct" | "ObservationDefinition">;
+    itemReference: Reference<'Medication' | 'Substance' | 'MedicinalProduct' | 'ObservationDefinition'>;
     itemCodeableConcept: CodeableConcept;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductManufactured.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductManufactured.d.ts
index 71c423c..d9470fe 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductManufactured.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductManufactured.d.ts
@@ -7,6 +7,7 @@ import { DomainResource } from "./DomainResource";
 import { Reference } from "./Reference";
 /** The manufactured item as contained in the packaged medicinal product. */
 export interface MedicinalProductManufactured extends DomainResource {
+    resourceType: 'MedicinalProductManufactured';
     /** Dose form as manufactured and before any transformation into the pharmaceutical product */
     manufacturedDoseForm: CodeableConcept;
     /** The “real world” units in which the quantity of the manufactured item is described */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductPackaged.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductPackaged.d.ts
index 4664694..ab7cf15 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductPackaged.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductPackaged.d.ts
@@ -12,13 +12,14 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A medicinal product in a container or package. */
 export interface MedicinalProductPackaged extends DomainResource {
+    resourceType: 'MedicinalProductPackaged';
     /** Textual description */
     description?: string;
     _description?: Element;
     /** Marketing information */
     marketingStatus?: Array<MarketingStatus>;
     /** Manufacturer of this Package Item */
-    marketingAuthorization?: Reference<"MedicinalProductAuthorization">;
+    marketingAuthorization?: Reference<'MedicinalProductAuthorization'>;
     /** Unique identifier */
     identifier?: Array<Identifier>;
     /** Manufacturer of this Package Item */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductPharmaceutical.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductPharmaceutical.d.ts
index 7c84d70..eb77b68 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductPharmaceutical.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductPharmaceutical.d.ts
@@ -11,6 +11,7 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A pharmaceutical product described in terms of its composition and dose form. */
 export interface MedicinalProductPharmaceutical extends DomainResource {
+    resourceType: 'MedicinalProductPharmaceutical';
     /** An identifier for the pharmaceutical medicinal product */
     identifier?: Array<Identifier>;
     /** The administrable dose form, after necessary reconstitution */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductUndesirableEffect.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductUndesirableEffect.d.ts
index e8bd4aa..8f3b738 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductUndesirableEffect.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MedicinalProductUndesirableEffect.d.ts
@@ -6,6 +6,7 @@ import { DomainResource } from "./DomainResource";
 import { Reference } from "./Reference";
 /** Describe the undesirable effects of the medicinal product. */
 export interface MedicinalProductUndesirableEffect extends DomainResource {
+    resourceType: 'MedicinalProductUndesirableEffect';
     /** The medication for which this is an indication */
     subject?: Array<Reference>;
     /** The symptom, condition or undesirable effect */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MessageDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MessageDefinition.d.ts
index 5b0376c..895b246 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MessageDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MessageDefinition.d.ts
@@ -11,16 +11,16 @@ import { canonical } from "./canonical";
 import { DomainResource } from "./DomainResource";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted. */
 export interface MessageDefinition extends DomainResource {
+    resourceType: 'MessageDefinition';
     _base?: Element;
     /** Natural language description of the message definition */
     description?: markdown;
     /** consequence | currency | notification */
-    category?: code;
+    category?: `${MessageDefinitionCategory}`;
     /** Date last changed */
     date: dateTime;
     _graph?: Array<Element>;
@@ -51,7 +51,7 @@ export interface MessageDefinition extends DomainResource {
     _description?: Element;
     _purpose?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${MessageDefinitionStatus}`;
     /** Responses to this message */
     allowedResponse?: Array<MessageDefinitionAllowedResponse>;
     /** Canonical reference to a GraphDefinition */
@@ -69,7 +69,7 @@ export interface MessageDefinition extends DomainResource {
     /** Takes the place of */
     replaces?: Array<canonical>;
     /** always | on-error | never | on-success */
-    responseRequired?: code;
+    responseRequired?: `${MessageDefinitionResponseRequired}`;
     _category?: Element;
     /** Definition this one is based on */
     base?: canonical;
@@ -83,6 +83,19 @@ export interface MessageDefinition extends DomainResource {
     _url?: Element;
     eventCoding: Coding;
 }
+/** consequence | currency | notification */
+export declare enum MessageDefinitionCategory {
+    Consequence = "consequence",
+    Currency = "currency",
+    Notification = "notification"
+}
+/** draft | active | retired | unknown */
+export declare enum MessageDefinitionStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
 /** Responses to this message */
 export interface MessageDefinitionAllowedResponse extends BackboneElement {
     /** Reference to allowed message definition response */
@@ -92,10 +105,161 @@ export interface MessageDefinitionAllowedResponse extends BackboneElement {
     situation?: markdown;
     _situation?: Element;
 }
+/** Type of resource */
+export declare enum MessageDefinitionCode {
+    ImmunizationEvaluation = "ImmunizationEvaluation",
+    Appointment = "Appointment",
+    StructureMap = "StructureMap",
+    CareTeam = "CareTeam",
+    Linkage = "Linkage",
+    Communication = "Communication",
+    MedicationDispense = "MedicationDispense",
+    ImagingStudy = "ImagingStudy",
+    ChargeItem = "ChargeItem",
+    AdverseEvent = "AdverseEvent",
+    Media = "Media",
+    SubstancePolymer = "SubstancePolymer",
+    QuestionnaireResponse = "QuestionnaireResponse",
+    Coverage = "Coverage",
+    Procedure = "Procedure",
+    AuditEvent = "AuditEvent",
+    PaymentReconciliation = "PaymentReconciliation",
+    MedicinalProductManufactured = "MedicinalProductManufactured",
+    CompartmentDefinition = "CompartmentDefinition",
+    Organization = "Organization",
+    ExplanationOfBenefit = "ExplanationOfBenefit",
+    Composition = "Composition",
+    CoverageEligibilityResponse = "CoverageEligibilityResponse",
+    DocumentReference = "DocumentReference",
+    EventDefinition = "EventDefinition",
+    SubstanceProtein = "SubstanceProtein",
+    TerminologyCapabilities = "TerminologyCapabilities",
+    Encounter = "Encounter",
+    ImplementationGuide = "ImplementationGuide",
+    EvidenceVariable = "EvidenceVariable",
+    ObservationDefinition = "ObservationDefinition",
+    DiagnosticReport = "DiagnosticReport",
+    ExampleScenario = "ExampleScenario",
+    ResearchDefinition = "ResearchDefinition",
+    Parameters = "Parameters",
+    SearchParameter = "SearchParameter",
+    MedicinalProductInteraction = "MedicinalProductInteraction",
+    CodeSystem = "CodeSystem",
+    MessageDefinition = "MessageDefinition",
+    NutritionOrder = "NutritionOrder",
+    VerificationResult = "VerificationResult",
+    MedicationAdministration = "MedicationAdministration",
+    CatalogEntry = "CatalogEntry",
+    Flag = "Flag",
+    DeviceUseStatement = "DeviceUseStatement",
+    Contract = "Contract",
+    Invoice = "Invoice",
+    PaymentNotice = "PaymentNotice",
+    Location = "Location",
+    Claim = "Claim",
+    Specimen = "Specimen",
+    MedicationStatement = "MedicationStatement",
+    EnrollmentResponse = "EnrollmentResponse",
+    Evidence = "Evidence",
+    Bundle = "Bundle",
+    ResearchElementDefinition = "ResearchElementDefinition",
+    BodyStructure = "BodyStructure",
+    MedicinalProduct = "MedicinalProduct",
+    ResearchStudy = "ResearchStudy",
+    AppointmentResponse = "AppointmentResponse",
+    MedicinalProductIndication = "MedicinalProductIndication",
+    Measure = "Measure",
+    Person = "Person",
+    InsurancePlan = "InsurancePlan",
+    Patient = "Patient",
+    EffectEvidenceSynthesis = "EffectEvidenceSynthesis",
+    ResearchSubject = "ResearchSubject",
+    Medication = "Medication",
+    ConceptMap = "ConceptMap",
+    CoverageEligibilityRequest = "CoverageEligibilityRequest",
+    SubstanceSourceMaterial = "SubstanceSourceMaterial",
+    VisionPrescription = "VisionPrescription",
+    MolecularSequence = "MolecularSequence",
+    MedicinalProductUndesirableEffect = "MedicinalProductUndesirableEffect",
+    OperationOutcome = "OperationOutcome",
+    MessageHeader = "MessageHeader",
+    AllergyIntolerance = "AllergyIntolerance",
+    SubstanceReferenceInformation = "SubstanceReferenceInformation",
+    SupplyDelivery = "SupplyDelivery",
+    EpisodeOfCare = "EpisodeOfCare",
+    PractitionerRole = "PractitionerRole",
+    Library = "Library",
+    Practitioner = "Practitioner",
+    MedicationRequest = "MedicationRequest",
+    ImmunizationRecommendation = "ImmunizationRecommendation",
+    Immunization = "Immunization",
+    GraphDefinition = "GraphDefinition",
+    Account = "Account",
+    MedicinalProductIngredient = "MedicinalProductIngredient",
+    MeasureReport = "MeasureReport",
+    DeviceMetric = "DeviceMetric",
+    Goal = "Goal",
+    MedicationKnowledge = "MedicationKnowledge",
+    ClaimResponse = "ClaimResponse",
+    DeviceDefinition = "DeviceDefinition",
+    Slot = "Slot",
+    ValueSet = "ValueSet",
+    MedicinalProductAuthorization = "MedicinalProductAuthorization",
+    StructureDefinition = "StructureDefinition",
+    MedicinalProductContraindication = "MedicinalProductContraindication",
+    DeviceRequest = "DeviceRequest",
+    List = "List",
+    Questionnaire = "Questionnaire",
+    DomainResource = "DomainResource",
+    Endpoint = "Endpoint",
+    NamingSystem = "NamingSystem",
+    MedicinalProductPackaged = "MedicinalProductPackaged",
+    Basic = "Basic",
+    Binary = "Binary",
+    PlanDefinition = "PlanDefinition",
+    Subscription = "Subscription",
+    RelatedPerson = "RelatedPerson",
+    SubstanceSpecification = "SubstanceSpecification",
+    SubstanceNucleicAcid = "SubstanceNucleicAcid",
+    GuidanceResponse = "GuidanceResponse",
+    ClinicalImpression = "ClinicalImpression",
+    OrganizationAffiliation = "OrganizationAffiliation",
+    Resource = "Resource",
+    Condition = "Condition",
+    CapabilityStatement = "CapabilityStatement",
+    HealthcareService = "HealthcareService",
+    SpecimenDefinition = "SpecimenDefinition",
+    RiskAssessment = "RiskAssessment",
+    OperationDefinition = "OperationDefinition",
+    ActivityDefinition = "ActivityDefinition",
+    Schedule = "Schedule",
+    BiologicallyDerivedProduct = "BiologicallyDerivedProduct",
+    Group = "Group",
+    MedicinalProductPharmaceutical = "MedicinalProductPharmaceutical",
+    FamilyMemberHistory = "FamilyMemberHistory",
+    ServiceRequest = "ServiceRequest",
+    DetectedIssue = "DetectedIssue",
+    Device = "Device",
+    RequestGroup = "RequestGroup",
+    TestScript = "TestScript",
+    RiskEvidenceSynthesis = "RiskEvidenceSynthesis",
+    SupplyRequest = "SupplyRequest",
+    Task = "Task",
+    CommunicationRequest = "CommunicationRequest",
+    EnrollmentRequest = "EnrollmentRequest",
+    ChargeItemDefinition = "ChargeItemDefinition",
+    Substance = "Substance",
+    Provenance = "Provenance",
+    Consent = "Consent",
+    CarePlan = "CarePlan",
+    TestReport = "TestReport",
+    Observation = "Observation",
+    DocumentManifest = "DocumentManifest"
+}
 /** Resource(s) that are the subject of the event */
 export interface MessageDefinitionFocus extends BackboneElement {
     /** Type of resource */
-    code: code;
+    code: `${MessageDefinitionCode}`;
     _code?: Element;
     /** Profile that must be adhered to by focus */
     profile?: canonical;
@@ -107,3 +271,10 @@ export interface MessageDefinitionFocus extends BackboneElement {
     max?: string;
     _max?: Element;
 }
+/** always | on-error | never | on-success */
+export declare enum MessageDefinitionResponseRequired {
+    Always = "always",
+    Never = "never",
+    OnError = "on-error",
+    OnSuccess = "on-success"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MessageDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/MessageDefinition.js
index c8ad2e5..f068450 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MessageDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/MessageDefinition.js
@@ -1,2 +1,178 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageDefinitionResponseRequired = exports.MessageDefinitionCode = exports.MessageDefinitionStatus = exports.MessageDefinitionCategory = void 0;
+/** consequence | currency | notification */
+var MessageDefinitionCategory;
+(function (MessageDefinitionCategory) {
+    MessageDefinitionCategory["Consequence"] = "consequence";
+    MessageDefinitionCategory["Currency"] = "currency";
+    MessageDefinitionCategory["Notification"] = "notification";
+})(MessageDefinitionCategory = exports.MessageDefinitionCategory || (exports.MessageDefinitionCategory = {}));
+/** draft | active | retired | unknown */
+var MessageDefinitionStatus;
+(function (MessageDefinitionStatus) {
+    MessageDefinitionStatus["Active"] = "active";
+    MessageDefinitionStatus["Draft"] = "draft";
+    MessageDefinitionStatus["Retired"] = "retired";
+    MessageDefinitionStatus["Unknown"] = "unknown";
+})(MessageDefinitionStatus = exports.MessageDefinitionStatus || (exports.MessageDefinitionStatus = {}));
+/** Type of resource */
+var MessageDefinitionCode;
+(function (MessageDefinitionCode) {
+    MessageDefinitionCode["ImmunizationEvaluation"] = "ImmunizationEvaluation";
+    MessageDefinitionCode["Appointment"] = "Appointment";
+    MessageDefinitionCode["StructureMap"] = "StructureMap";
+    MessageDefinitionCode["CareTeam"] = "CareTeam";
+    MessageDefinitionCode["Linkage"] = "Linkage";
+    MessageDefinitionCode["Communication"] = "Communication";
+    MessageDefinitionCode["MedicationDispense"] = "MedicationDispense";
+    MessageDefinitionCode["ImagingStudy"] = "ImagingStudy";
+    MessageDefinitionCode["ChargeItem"] = "ChargeItem";
+    MessageDefinitionCode["AdverseEvent"] = "AdverseEvent";
+    MessageDefinitionCode["Media"] = "Media";
+    MessageDefinitionCode["SubstancePolymer"] = "SubstancePolymer";
+    MessageDefinitionCode["QuestionnaireResponse"] = "QuestionnaireResponse";
+    MessageDefinitionCode["Coverage"] = "Coverage";
+    MessageDefinitionCode["Procedure"] = "Procedure";
+    MessageDefinitionCode["AuditEvent"] = "AuditEvent";
+    MessageDefinitionCode["PaymentReconciliation"] = "PaymentReconciliation";
+    MessageDefinitionCode["MedicinalProductManufactured"] = "MedicinalProductManufactured";
+    MessageDefinitionCode["CompartmentDefinition"] = "CompartmentDefinition";
+    MessageDefinitionCode["Organization"] = "Organization";
+    MessageDefinitionCode["ExplanationOfBenefit"] = "ExplanationOfBenefit";
+    MessageDefinitionCode["Composition"] = "Composition";
+    MessageDefinitionCode["CoverageEligibilityResponse"] = "CoverageEligibilityResponse";
+    MessageDefinitionCode["DocumentReference"] = "DocumentReference";
+    MessageDefinitionCode["EventDefinition"] = "EventDefinition";
+    MessageDefinitionCode["SubstanceProtein"] = "SubstanceProtein";
+    MessageDefinitionCode["TerminologyCapabilities"] = "TerminologyCapabilities";
+    MessageDefinitionCode["Encounter"] = "Encounter";
+    MessageDefinitionCode["ImplementationGuide"] = "ImplementationGuide";
+    MessageDefinitionCode["EvidenceVariable"] = "EvidenceVariable";
+    MessageDefinitionCode["ObservationDefinition"] = "ObservationDefinition";
+    MessageDefinitionCode["DiagnosticReport"] = "DiagnosticReport";
+    MessageDefinitionCode["ExampleScenario"] = "ExampleScenario";
+    MessageDefinitionCode["ResearchDefinition"] = "ResearchDefinition";
+    MessageDefinitionCode["Parameters"] = "Parameters";
+    MessageDefinitionCode["SearchParameter"] = "SearchParameter";
+    MessageDefinitionCode["MedicinalProductInteraction"] = "MedicinalProductInteraction";
+    MessageDefinitionCode["CodeSystem"] = "CodeSystem";
+    MessageDefinitionCode["MessageDefinition"] = "MessageDefinition";
+    MessageDefinitionCode["NutritionOrder"] = "NutritionOrder";
+    MessageDefinitionCode["VerificationResult"] = "VerificationResult";
+    MessageDefinitionCode["MedicationAdministration"] = "MedicationAdministration";
+    MessageDefinitionCode["CatalogEntry"] = "CatalogEntry";
+    MessageDefinitionCode["Flag"] = "Flag";
+    MessageDefinitionCode["DeviceUseStatement"] = "DeviceUseStatement";
+    MessageDefinitionCode["Contract"] = "Contract";
+    MessageDefinitionCode["Invoice"] = "Invoice";
+    MessageDefinitionCode["PaymentNotice"] = "PaymentNotice";
+    MessageDefinitionCode["Location"] = "Location";
+    MessageDefinitionCode["Claim"] = "Claim";
+    MessageDefinitionCode["Specimen"] = "Specimen";
+    MessageDefinitionCode["MedicationStatement"] = "MedicationStatement";
+    MessageDefinitionCode["EnrollmentResponse"] = "EnrollmentResponse";
+    MessageDefinitionCode["Evidence"] = "Evidence";
+    MessageDefinitionCode["Bundle"] = "Bundle";
+    MessageDefinitionCode["ResearchElementDefinition"] = "ResearchElementDefinition";
+    MessageDefinitionCode["BodyStructure"] = "BodyStructure";
+    MessageDefinitionCode["MedicinalProduct"] = "MedicinalProduct";
+    MessageDefinitionCode["ResearchStudy"] = "ResearchStudy";
+    MessageDefinitionCode["AppointmentResponse"] = "AppointmentResponse";
+    MessageDefinitionCode["MedicinalProductIndication"] = "MedicinalProductIndication";
+    MessageDefinitionCode["Measure"] = "Measure";
+    MessageDefinitionCode["Person"] = "Person";
+    MessageDefinitionCode["InsurancePlan"] = "InsurancePlan";
+    MessageDefinitionCode["Patient"] = "Patient";
+    MessageDefinitionCode["EffectEvidenceSynthesis"] = "EffectEvidenceSynthesis";
+    MessageDefinitionCode["ResearchSubject"] = "ResearchSubject";
+    MessageDefinitionCode["Medication"] = "Medication";
+    MessageDefinitionCode["ConceptMap"] = "ConceptMap";
+    MessageDefinitionCode["CoverageEligibilityRequest"] = "CoverageEligibilityRequest";
+    MessageDefinitionCode["SubstanceSourceMaterial"] = "SubstanceSourceMaterial";
+    MessageDefinitionCode["VisionPrescription"] = "VisionPrescription";
+    MessageDefinitionCode["MolecularSequence"] = "MolecularSequence";
+    MessageDefinitionCode["MedicinalProductUndesirableEffect"] = "MedicinalProductUndesirableEffect";
+    MessageDefinitionCode["OperationOutcome"] = "OperationOutcome";
+    MessageDefinitionCode["MessageHeader"] = "MessageHeader";
+    MessageDefinitionCode["AllergyIntolerance"] = "AllergyIntolerance";
+    MessageDefinitionCode["SubstanceReferenceInformation"] = "SubstanceReferenceInformation";
+    MessageDefinitionCode["SupplyDelivery"] = "SupplyDelivery";
+    MessageDefinitionCode["EpisodeOfCare"] = "EpisodeOfCare";
+    MessageDefinitionCode["PractitionerRole"] = "PractitionerRole";
+    MessageDefinitionCode["Library"] = "Library";
+    MessageDefinitionCode["Practitioner"] = "Practitioner";
+    MessageDefinitionCode["MedicationRequest"] = "MedicationRequest";
+    MessageDefinitionCode["ImmunizationRecommendation"] = "ImmunizationRecommendation";
+    MessageDefinitionCode["Immunization"] = "Immunization";
+    MessageDefinitionCode["GraphDefinition"] = "GraphDefinition";
+    MessageDefinitionCode["Account"] = "Account";
+    MessageDefinitionCode["MedicinalProductIngredient"] = "MedicinalProductIngredient";
+    MessageDefinitionCode["MeasureReport"] = "MeasureReport";
+    MessageDefinitionCode["DeviceMetric"] = "DeviceMetric";
+    MessageDefinitionCode["Goal"] = "Goal";
+    MessageDefinitionCode["MedicationKnowledge"] = "MedicationKnowledge";
+    MessageDefinitionCode["ClaimResponse"] = "ClaimResponse";
+    MessageDefinitionCode["DeviceDefinition"] = "DeviceDefinition";
+    MessageDefinitionCode["Slot"] = "Slot";
+    MessageDefinitionCode["ValueSet"] = "ValueSet";
+    MessageDefinitionCode["MedicinalProductAuthorization"] = "MedicinalProductAuthorization";
+    MessageDefinitionCode["StructureDefinition"] = "StructureDefinition";
+    MessageDefinitionCode["MedicinalProductContraindication"] = "MedicinalProductContraindication";
+    MessageDefinitionCode["DeviceRequest"] = "DeviceRequest";
+    MessageDefinitionCode["List"] = "List";
+    MessageDefinitionCode["Questionnaire"] = "Questionnaire";
+    MessageDefinitionCode["DomainResource"] = "DomainResource";
+    MessageDefinitionCode["Endpoint"] = "Endpoint";
+    MessageDefinitionCode["NamingSystem"] = "NamingSystem";
+    MessageDefinitionCode["MedicinalProductPackaged"] = "MedicinalProductPackaged";
+    MessageDefinitionCode["Basic"] = "Basic";
+    MessageDefinitionCode["Binary"] = "Binary";
+    MessageDefinitionCode["PlanDefinition"] = "PlanDefinition";
+    MessageDefinitionCode["Subscription"] = "Subscription";
+    MessageDefinitionCode["RelatedPerson"] = "RelatedPerson";
+    MessageDefinitionCode["SubstanceSpecification"] = "SubstanceSpecification";
+    MessageDefinitionCode["SubstanceNucleicAcid"] = "SubstanceNucleicAcid";
+    MessageDefinitionCode["GuidanceResponse"] = "GuidanceResponse";
+    MessageDefinitionCode["ClinicalImpression"] = "ClinicalImpression";
+    MessageDefinitionCode["OrganizationAffiliation"] = "OrganizationAffiliation";
+    MessageDefinitionCode["Resource"] = "Resource";
+    MessageDefinitionCode["Condition"] = "Condition";
+    MessageDefinitionCode["CapabilityStatement"] = "CapabilityStatement";
+    MessageDefinitionCode["HealthcareService"] = "HealthcareService";
+    MessageDefinitionCode["SpecimenDefinition"] = "SpecimenDefinition";
+    MessageDefinitionCode["RiskAssessment"] = "RiskAssessment";
+    MessageDefinitionCode["OperationDefinition"] = "OperationDefinition";
+    MessageDefinitionCode["ActivityDefinition"] = "ActivityDefinition";
+    MessageDefinitionCode["Schedule"] = "Schedule";
+    MessageDefinitionCode["BiologicallyDerivedProduct"] = "BiologicallyDerivedProduct";
+    MessageDefinitionCode["Group"] = "Group";
+    MessageDefinitionCode["MedicinalProductPharmaceutical"] = "MedicinalProductPharmaceutical";
+    MessageDefinitionCode["FamilyMemberHistory"] = "FamilyMemberHistory";
+    MessageDefinitionCode["ServiceRequest"] = "ServiceRequest";
+    MessageDefinitionCode["DetectedIssue"] = "DetectedIssue";
+    MessageDefinitionCode["Device"] = "Device";
+    MessageDefinitionCode["RequestGroup"] = "RequestGroup";
+    MessageDefinitionCode["TestScript"] = "TestScript";
+    MessageDefinitionCode["RiskEvidenceSynthesis"] = "RiskEvidenceSynthesis";
+    MessageDefinitionCode["SupplyRequest"] = "SupplyRequest";
+    MessageDefinitionCode["Task"] = "Task";
+    MessageDefinitionCode["CommunicationRequest"] = "CommunicationRequest";
+    MessageDefinitionCode["EnrollmentRequest"] = "EnrollmentRequest";
+    MessageDefinitionCode["ChargeItemDefinition"] = "ChargeItemDefinition";
+    MessageDefinitionCode["Substance"] = "Substance";
+    MessageDefinitionCode["Provenance"] = "Provenance";
+    MessageDefinitionCode["Consent"] = "Consent";
+    MessageDefinitionCode["CarePlan"] = "CarePlan";
+    MessageDefinitionCode["TestReport"] = "TestReport";
+    MessageDefinitionCode["Observation"] = "Observation";
+    MessageDefinitionCode["DocumentManifest"] = "DocumentManifest";
+})(MessageDefinitionCode = exports.MessageDefinitionCode || (exports.MessageDefinitionCode = {}));
+/** always | on-error | never | on-success */
+var MessageDefinitionResponseRequired;
+(function (MessageDefinitionResponseRequired) {
+    MessageDefinitionResponseRequired["Always"] = "always";
+    MessageDefinitionResponseRequired["Never"] = "never";
+    MessageDefinitionResponseRequired["OnError"] = "on-error";
+    MessageDefinitionResponseRequired["OnSuccess"] = "on-success";
+})(MessageDefinitionResponseRequired = exports.MessageDefinitionResponseRequired || (exports.MessageDefinitionResponseRequired = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MessageHeader.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MessageHeader.d.ts
index 998a95e..914114e 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MessageHeader.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MessageHeader.d.ts
@@ -10,27 +10,27 @@ import { canonical } from "./canonical";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** The header for a message exchange that is either requesting or responding to an action.  The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle. */
 export interface MessageHeader extends DomainResource {
+    resourceType: 'MessageHeader';
     /** If this is a reply to prior message */
     response?: MessageHeaderResponse;
     /** Link to the definition for this message */
     definition?: canonical;
     /** The source of the data entry */
-    enterer?: Reference<"PractitionerRole" | "Practitioner">;
+    enterer?: Reference<'PractitionerRole' | 'Practitioner'>;
     _definition?: Element;
     /** Message source application */
     source: MessageHeaderSource;
     /** The source of the decision */
-    author?: Reference<"PractitionerRole" | "Practitioner">;
+    author?: Reference<'PractitionerRole' | 'Practitioner'>;
     /** Cause of event */
     reason?: CodeableConcept;
     /** Final responsibility for event */
-    responsible?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    responsible?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Real world sender of the message */
-    sender?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    sender?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** The actual content of the message */
     focus?: Array<Reference>;
     _eventUri: Element;
@@ -39,16 +39,22 @@ export interface MessageHeader extends DomainResource {
     destination?: Array<MessageHeaderDestination>;
     eventCoding: Coding;
 }
+/** ok | transient-error | fatal-error */
+export declare enum MessageHeaderCode {
+    FatalError = "fatal-error",
+    Ok = "ok",
+    TransientError = "transient-error"
+}
 /** If this is a reply to prior message */
 export interface MessageHeaderResponse extends BackboneElement {
     /** Id of original message */
     identifier: id;
     _identifier?: Element;
     /** ok | transient-error | fatal-error */
-    code: code;
+    code: `${MessageHeaderCode}`;
     _code?: Element;
     /** Specific list of hints/warnings/errors */
-    details?: Reference<"OperationOutcome">;
+    details?: Reference<'OperationOutcome'>;
 }
 /** Message source application */
 export interface MessageHeaderSource extends BackboneElement {
@@ -73,10 +79,10 @@ export interface MessageHeaderDestination extends BackboneElement {
     name?: string;
     _name?: Element;
     /** Particular delivery destination within the destination */
-    target?: Reference<"Device">;
+    target?: Reference<'Device'>;
     /** Actual destination address or id */
     endpoint: url;
     _endpoint?: Element;
     /** Intended "real-world" recipient for the data */
-    receiver?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    receiver?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MessageHeader.js b/vendor/r4/types/hl7-fhir-r4-core/MessageHeader.js
index c8ad2e5..03756ad 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MessageHeader.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/MessageHeader.js
@@ -1,2 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageHeaderCode = void 0;
+/** ok | transient-error | fatal-error */
+var MessageHeaderCode;
+(function (MessageHeaderCode) {
+    MessageHeaderCode["FatalError"] = "fatal-error";
+    MessageHeaderCode["Ok"] = "ok";
+    MessageHeaderCode["TransientError"] = "transient-error";
+})(MessageHeaderCode = exports.MessageHeaderCode || (exports.MessageHeaderCode = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MolecularSequence.d.ts b/vendor/r4/types/hl7-fhir-r4-core/MolecularSequence.d.ts
index d2d5dda..01d4562 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MolecularSequence.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/MolecularSequence.d.ts
@@ -7,14 +7,14 @@ import { integer } from "./integer";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** Raw data describing a biological sequence. */
 export interface MolecularSequence extends DomainResource {
+    resourceType: 'MolecularSequence';
     /** Who and/or what this is about */
-    patient?: Reference<"Patient">;
+    patient?: Reference<'Patient'>;
     /** Structural variant */
     structureVariant?: Array<MolecularSequenceStructureVariant>;
     /** External repository which contains detailed report related with observedSeq in this resource */
@@ -22,10 +22,10 @@ export interface MolecularSequence extends DomainResource {
     /** Variant in sequence */
     variant?: Array<MolecularSequenceVariant>;
     /** Specimen used for sequencing */
-    specimen?: Reference<"Specimen">;
+    specimen?: Reference<'Specimen'>;
     _type?: Element;
     /** aa | dna | rna */
-    type?: code;
+    type?: `${MolecularSequenceType}`;
     _coordinateSystem?: Element;
     _observedSeq?: Element;
     _readCoverage?: Element;
@@ -38,7 +38,7 @@ export interface MolecularSequence extends DomainResource {
     /** An set of value as quality of sequence */
     quality?: Array<MolecularSequenceQuality>;
     /** The method for sequencing */
-    device?: Reference<"Device">;
+    device?: Reference<'Device'>;
     /** The number of copies of the sequence of interest.  (RNASeq) */
     quantity?: Quantity;
     /** Base number of coordinate system (0 for 0-based numbering or coordinates, inclusive start, exclusive end, 1 for 1-based numbering, inclusive start, inclusive end) */
@@ -46,43 +46,10 @@ export interface MolecularSequence extends DomainResource {
     /** A sequence used as reference */
     referenceSeq?: MolecularSequenceReferenceSeq;
     /** Who should be responsible for test result */
-    performer?: Reference<"Organization">;
+    performer?: Reference<'Organization'>;
     /** Average number of reads representing a given nucleotide in the reconstructed sequence */
     readCoverage?: integer;
 }
-/** Structural variant outer */
-export interface MolecularSequenceOuter extends BackboneElement {
-    /** Structural variant outer start */
-    start?: integer;
-    _start?: Element;
-    /** Structural variant outer end */
-    end?: integer;
-    _end?: Element;
-}
-/** Structural variant inner */
-export interface MolecularSequenceInner extends BackboneElement {
-    /** Structural variant inner start */
-    start?: integer;
-    _start?: Element;
-    /** Structural variant inner end */
-    end?: integer;
-    _end?: Element;
-}
-/** Structural variant */
-export interface MolecularSequenceStructureVariant extends BackboneElement {
-    /** Structural variant change type */
-    variantType?: CodeableConcept;
-    /** Does the structural variant have base pair resolution breakpoints? */
-    exact?: boolean;
-    _exact?: Element;
-    /** Structural variant length */
-    length?: integer;
-    _length?: Element;
-    /** Structural variant outer */
-    outer?: MolecularSequenceOuter;
-    /** Structural variant inner */
-    inner?: MolecularSequenceInner;
-}
 /** External repository which contains detailed report related with observedSeq in this resource */
 export interface MolecularSequenceRepository extends BackboneElement {
     /** Id of the read */
@@ -91,7 +58,7 @@ export interface MolecularSequenceRepository extends BackboneElement {
     name?: string;
     _type?: Element;
     /** directlink | openapi | login | oauth | other */
-    type: code;
+    type: `${MolecularSequenceType}`;
     _datasetId?: Element;
     /** Id of the dataset that used to call for dataset in repository */
     datasetId?: string;
@@ -104,25 +71,45 @@ export interface MolecularSequenceRepository extends BackboneElement {
     _readsetId?: Element;
     _url?: Element;
 }
-/** Variant in sequence */
-export interface MolecularSequenceVariant extends BackboneElement {
-    /** Pointer to observed variant information */
-    variantPointer?: Reference<"Observation">;
-    /** Allele in the reference sequence */
-    referenceAllele?: string;
-    _end?: Element;
-    /** Start position of the variant on the  reference sequence */
+/** indel | snp | unknown */
+export declare enum MolecularSequenceType {
+    Indel = "indel",
+    Snp = "snp",
+    Unknown = "unknown"
+}
+/** Structural variant */
+export interface MolecularSequenceStructureVariant extends BackboneElement {
+    /** Structural variant change type */
+    variantType?: CodeableConcept;
+    /** Does the structural variant have base pair resolution breakpoints? */
+    exact?: boolean;
+    _exact?: Element;
+    /** Structural variant length */
+    length?: integer;
+    _length?: Element;
+    /** Structural variant outer */
+    outer?: MolecularSequenceOuter;
+    /** Structural variant inner */
+    inner?: MolecularSequenceInner;
+}
+/** Structural variant outer */
+export interface MolecularSequenceOuter extends BackboneElement {
+    /** Structural variant outer start */
     start?: integer;
-    _observedAllele?: Element;
-    _referenceAllele?: Element;
-    /** Allele that was observed */
-    observedAllele?: string;
-    _cigar?: Element;
-    /** End position of the variant on the reference sequence */
-    end?: integer;
     _start?: Element;
-    /** Extended CIGAR string for aligning the sequence with reference bases */
-    cigar?: string;
+    /** Structural variant outer end */
+    end?: integer;
+    _end?: Element;
+}
+/** watson | crick */
+export declare enum MolecularSequenceStrand {
+    Crick = "crick",
+    Watson = "watson"
+}
+/** sense | antisense */
+export declare enum MolecularSequenceOrientation {
+    Antisense = "antisense",
+    Sense = "sense"
 }
 /** Receiver Operator Characteristic (ROC) Curve */
 export interface MolecularSequenceRoc extends BackboneElement {
@@ -148,6 +135,33 @@ export interface MolecularSequenceRoc extends BackboneElement {
     /** Roc score true positive numbers */
     numTP?: Array<integer>;
 }
+/** A sequence used as reference */
+export interface MolecularSequenceReferenceSeq extends BackboneElement {
+    /** Chromosome containing genetic finding */
+    chromosome?: CodeableConcept;
+    /** Reference identifier */
+    referenceSeqId?: CodeableConcept;
+    _referenceSeqString?: Element;
+    /** End position of the window on the reference sequence */
+    windowEnd?: integer;
+    _genomeBuild?: Element;
+    /** watson | crick */
+    strand?: `${MolecularSequenceStrand}`;
+    /** The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37' */
+    genomeBuild?: string;
+    /** sense | antisense */
+    orientation?: `${MolecularSequenceOrientation}`;
+    _strand?: Element;
+    /** A pointer to another MolecularSequence entity as reference sequence */
+    referenceSeqPointer?: Reference<'MolecularSequence'>;
+    _windowStart?: Element;
+    _orientation?: Element;
+    /** A string to represent reference sequence */
+    referenceSeqString?: string;
+    _windowEnd?: Element;
+    /** Start position of the window on the  reference sequence */
+    windowStart?: integer;
+}
 /** An set of value as quality of sequence */
 export interface MolecularSequenceQuality extends BackboneElement {
     /** True positives from the perspective of the truth data */
@@ -170,7 +184,7 @@ export interface MolecularSequenceQuality extends BackboneElement {
     /** True positives from the perspective of the query data */
     queryTP?: decimal;
     /** indel | snp | unknown */
-    type: code;
+    type: `${MolecularSequenceType}`;
     _truthFN?: Element;
     _gtFP?: Element;
     /** Recall of comparison */
@@ -192,30 +206,32 @@ export interface MolecularSequenceQuality extends BackboneElement {
     /** False positives where the non-REF alleles in the Truth and Query Call Sets match */
     gtFP?: decimal;
 }
-/** A sequence used as reference */
-export interface MolecularSequenceReferenceSeq extends BackboneElement {
-    /** Chromosome containing genetic finding */
-    chromosome?: CodeableConcept;
-    /** Reference identifier */
-    referenceSeqId?: CodeableConcept;
-    _referenceSeqString?: Element;
-    /** End position of the window on the reference sequence */
-    windowEnd?: integer;
-    _genomeBuild?: Element;
-    /** watson | crick */
-    strand?: code;
-    /** The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37' */
-    genomeBuild?: string;
-    /** sense | antisense */
-    orientation?: code;
-    _strand?: Element;
-    /** A pointer to another MolecularSequence entity as reference sequence */
-    referenceSeqPointer?: Reference<"MolecularSequence">;
-    _windowStart?: Element;
-    _orientation?: Element;
-    /** A string to represent reference sequence */
-    referenceSeqString?: string;
-    _windowEnd?: Element;
-    /** Start position of the window on the  reference sequence */
-    windowStart?: integer;
+/** Structural variant inner */
+export interface MolecularSequenceInner extends BackboneElement {
+    /** Structural variant inner start */
+    start?: integer;
+    _start?: Element;
+    /** Structural variant inner end */
+    end?: integer;
+    _end?: Element;
+}
+/** Variant in sequence */
+export interface MolecularSequenceVariant extends BackboneElement {
+    /** Pointer to observed variant information */
+    variantPointer?: Reference<'Observation'>;
+    /** Allele in the reference sequence */
+    referenceAllele?: string;
+    _end?: Element;
+    /** Start position of the variant on the  reference sequence */
+    start?: integer;
+    _observedAllele?: Element;
+    _referenceAllele?: Element;
+    /** Allele that was observed */
+    observedAllele?: string;
+    _cigar?: Element;
+    /** End position of the variant on the reference sequence */
+    end?: integer;
+    _start?: Element;
+    /** Extended CIGAR string for aligning the sequence with reference bases */
+    cigar?: string;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/MolecularSequence.js b/vendor/r4/types/hl7-fhir-r4-core/MolecularSequence.js
index c8ad2e5..3dbecdf 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/MolecularSequence.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/MolecularSequence.js
@@ -1,2 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MolecularSequenceOrientation = exports.MolecularSequenceStrand = exports.MolecularSequenceType = void 0;
+/** indel | snp | unknown */
+var MolecularSequenceType;
+(function (MolecularSequenceType) {
+    MolecularSequenceType["Indel"] = "indel";
+    MolecularSequenceType["Snp"] = "snp";
+    MolecularSequenceType["Unknown"] = "unknown";
+})(MolecularSequenceType = exports.MolecularSequenceType || (exports.MolecularSequenceType = {}));
+/** watson | crick */
+var MolecularSequenceStrand;
+(function (MolecularSequenceStrand) {
+    MolecularSequenceStrand["Crick"] = "crick";
+    MolecularSequenceStrand["Watson"] = "watson";
+})(MolecularSequenceStrand = exports.MolecularSequenceStrand || (exports.MolecularSequenceStrand = {}));
+/** sense | antisense */
+var MolecularSequenceOrientation;
+(function (MolecularSequenceOrientation) {
+    MolecularSequenceOrientation["Antisense"] = "antisense";
+    MolecularSequenceOrientation["Sense"] = "sense";
+})(MolecularSequenceOrientation = exports.MolecularSequenceOrientation || (exports.MolecularSequenceOrientation = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Money.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Money.d.ts
index 5152877..946dd7a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Money.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Money.d.ts
@@ -9,6 +9,6 @@ export interface Money extends Element {
     value?: decimal;
     _value?: Element;
     /** ISO 4217 Currency Code */
-    currency?: code;
+    currency?: `${code}`;
     _currency?: Element;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/NamingSystem.d.ts b/vendor/r4/types/hl7-fhir-r4-core/NamingSystem.d.ts
index 9355696..100aa50 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/NamingSystem.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/NamingSystem.d.ts
@@ -8,10 +8,10 @@ import { dateTime } from "./dateTime";
 import { DomainResource } from "./DomainResource";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
-import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc.  Represents a "System" used within the Identifier and Coding data types. */
 export interface NamingSystem extends DomainResource {
+    resourceType: 'NamingSystem';
     /** Natural language description of the naming system */
     description?: markdown;
     _usage?: Element;
@@ -38,22 +38,42 @@ export interface NamingSystem extends DomainResource {
     /** How/where is it used */
     usage?: string;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${NamingSystemStatus}`;
     /** codesystem | identifier | root */
-    kind: code;
+    kind: `${NamingSystemKind}`;
     _name?: Element;
     /** Unique identifiers used for system */
     uniqueId: Array<NamingSystemUniqueId>;
     /** Contact details for the publisher */
     contact?: Array<ContactDetail>;
 }
+/** draft | active | retired | unknown */
+export declare enum NamingSystemStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** codesystem | identifier | root */
+export declare enum NamingSystemKind {
+    Codesystem = "codesystem",
+    Identifier = "identifier",
+    Root = "root"
+}
+/** oid | uuid | uri | other */
+export declare enum NamingSystemType {
+    Oid = "oid",
+    Other = "other",
+    Uri = "uri",
+    Uuid = "uuid"
+}
 /** Unique identifiers used for system */
 export interface NamingSystemUniqueId extends BackboneElement {
     /** The unique identifier */
     value: string;
     _type?: Element;
     /** oid | uuid | uri | other */
-    type: code;
+    type: `${NamingSystemType}`;
     _value?: Element;
     /** Notes about identifier usage */
     comment?: string;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/NamingSystem.js b/vendor/r4/types/hl7-fhir-r4-core/NamingSystem.js
index c8ad2e5..a51a8c2 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/NamingSystem.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/NamingSystem.js
@@ -1,2 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamingSystemType = exports.NamingSystemKind = exports.NamingSystemStatus = void 0;
+/** draft | active | retired | unknown */
+var NamingSystemStatus;
+(function (NamingSystemStatus) {
+    NamingSystemStatus["Active"] = "active";
+    NamingSystemStatus["Draft"] = "draft";
+    NamingSystemStatus["Retired"] = "retired";
+    NamingSystemStatus["Unknown"] = "unknown";
+})(NamingSystemStatus = exports.NamingSystemStatus || (exports.NamingSystemStatus = {}));
+/** codesystem | identifier | root */
+var NamingSystemKind;
+(function (NamingSystemKind) {
+    NamingSystemKind["Codesystem"] = "codesystem";
+    NamingSystemKind["Identifier"] = "identifier";
+    NamingSystemKind["Root"] = "root";
+})(NamingSystemKind = exports.NamingSystemKind || (exports.NamingSystemKind = {}));
+/** oid | uuid | uri | other */
+var NamingSystemType;
+(function (NamingSystemType) {
+    NamingSystemType["Oid"] = "oid";
+    NamingSystemType["Other"] = "other";
+    NamingSystemType["Uri"] = "uri";
+    NamingSystemType["Uuid"] = "uuid";
+})(NamingSystemType = exports.NamingSystemType || (exports.NamingSystemType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Narrative.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Narrative.d.ts
index c4efcf8..3894588 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Narrative.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Narrative.d.ts
@@ -2,13 +2,19 @@
 DON'T MODIFY MANUALLY */
 import { xhtml } from "./xhtml";
 import { Element } from "./Element";
-import { code } from "./code";
 /** Base StructureDefinition for Narrative Type: A human-readable summary of the resource conveying the essential clinical and business information for the resource. */
 export interface Narrative extends Element {
     /** generated | extensions | additional | empty */
-    status: code;
+    status: `${NarrativeStatus}`;
     _status?: Element;
     /** Limited xhtml content */
     div: xhtml;
     _div?: Element;
 }
+/** generated | extensions | additional | empty */
+export declare enum NarrativeStatus {
+    Additional = "additional",
+    Empty = "empty",
+    Extensions = "extensions",
+    Generated = "generated"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Narrative.js b/vendor/r4/types/hl7-fhir-r4-core/Narrative.js
index c8ad2e5..330e2a5 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Narrative.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Narrative.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NarrativeStatus = void 0;
+/** generated | extensions | additional | empty */
+var NarrativeStatus;
+(function (NarrativeStatus) {
+    NarrativeStatus["Additional"] = "additional";
+    NarrativeStatus["Empty"] = "empty";
+    NarrativeStatus["Extensions"] = "extensions";
+    NarrativeStatus["Generated"] = "generated";
+})(NarrativeStatus = exports.NarrativeStatus || (exports.NarrativeStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/NutritionOrder.d.ts b/vendor/r4/types/hl7-fhir-r4-core/NutritionOrder.d.ts
index 4d6dfb0..b12bb2d 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/NutritionOrder.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/NutritionOrder.d.ts
@@ -12,13 +12,13 @@ import { DomainResource } from "./DomainResource";
 import { Ratio } from "./Ratio";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident. */
 export interface NutritionOrder extends DomainResource {
+    resourceType: 'NutritionOrder';
     /** The person who requires the diet, formula or nutritional supplement */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** Oral diet components */
     oralDiet?: NutritionOrderOralDiet;
     /** Instantiates FHIR protocol or definition */
@@ -28,7 +28,7 @@ export interface NutritionOrder extends DomainResource {
     /** Instantiates protocol or definition */
     instantiates?: Array<uri>;
     /** The encounter associated with this nutrition order */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _dateTime?: Element;
     _instantiates?: Array<Element>;
     _status?: Element;
@@ -42,15 +42,15 @@ export interface NutritionOrder extends DomainResource {
     /** Order-specific modifier about the type of food that should be given */
     foodPreferenceModifier?: Array<CodeableConcept>;
     /** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
-    status: code;
+    status: `${NutritionOrderStatus}`;
     /** Order-specific modifier about the type of food that should not be given */
     excludeFoodModifier?: Array<CodeableConcept>;
     /** Identifiers assigned to this order */
     identifier?: Array<Identifier>;
     /** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
-    intent: code;
+    intent: `${NutritionOrderIntent}`;
     /** Who ordered the diet, formula or nutritional supplement */
-    orderer?: Reference<"PractitionerRole" | "Practitioner">;
+    orderer?: Reference<'PractitionerRole' | 'Practitioner'>;
     /** Supplement components */
     supplement?: Array<NutritionOrderSupplement>;
     _instantiatesCanonical?: Array<Element>;
@@ -121,6 +121,28 @@ export interface NutritionOrderEnteralFormula extends BackboneElement {
     /** Product or brand name of the enteral or infant formula */
     baseFormulaProductName?: string;
 }
+/** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
+export declare enum NutritionOrderStatus {
+    Active = "active",
+    Completed = "completed",
+    Draft = "draft",
+    EnteredInError = "entered-in-error",
+    OnHold = "on-hold",
+    Revoked = "revoked",
+    Unknown = "unknown"
+}
+/** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
+export declare enum NutritionOrderIntent {
+    Order = "order",
+    FillerOrder = "filler-order",
+    Option = "option",
+    Directive = "directive",
+    Proposal = "proposal",
+    ReflexOrder = "reflex-order",
+    Plan = "plan",
+    InstanceOrder = "instance-order",
+    OriginalOrder = "original-order"
+}
 /** Supplement components */
 export interface NutritionOrderSupplement extends BackboneElement {
     /** Type of supplement product requested */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/NutritionOrder.js b/vendor/r4/types/hl7-fhir-r4-core/NutritionOrder.js
index c8ad2e5..0c96569 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/NutritionOrder.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/NutritionOrder.js
@@ -1,2 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NutritionOrderIntent = exports.NutritionOrderStatus = void 0;
+/** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
+var NutritionOrderStatus;
+(function (NutritionOrderStatus) {
+    NutritionOrderStatus["Active"] = "active";
+    NutritionOrderStatus["Completed"] = "completed";
+    NutritionOrderStatus["Draft"] = "draft";
+    NutritionOrderStatus["EnteredInError"] = "entered-in-error";
+    NutritionOrderStatus["OnHold"] = "on-hold";
+    NutritionOrderStatus["Revoked"] = "revoked";
+    NutritionOrderStatus["Unknown"] = "unknown";
+})(NutritionOrderStatus = exports.NutritionOrderStatus || (exports.NutritionOrderStatus = {}));
+/** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
+var NutritionOrderIntent;
+(function (NutritionOrderIntent) {
+    NutritionOrderIntent["Order"] = "order";
+    NutritionOrderIntent["FillerOrder"] = "filler-order";
+    NutritionOrderIntent["Option"] = "option";
+    NutritionOrderIntent["Directive"] = "directive";
+    NutritionOrderIntent["Proposal"] = "proposal";
+    NutritionOrderIntent["ReflexOrder"] = "reflex-order";
+    NutritionOrderIntent["Plan"] = "plan";
+    NutritionOrderIntent["InstanceOrder"] = "instance-order";
+    NutritionOrderIntent["OriginalOrder"] = "original-order";
+})(NutritionOrderIntent = exports.NutritionOrderIntent || (exports.NutritionOrderIntent = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Observation.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Observation.d.ts
index 43aaf9d..fd62de9 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Observation.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Observation.d.ts
@@ -16,11 +16,11 @@ import { Ratio } from "./Ratio";
 import { instant } from "./instant";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Measurements and simple assertions made about a patient, device or other subject. */
 export interface Observation extends DomainResource {
+    resourceType: 'Observation';
     /** Classification of  type of observation */
     category?: Array<CodeableConcept>;
     _issued?: Element;
@@ -34,12 +34,12 @@ export interface Observation extends DomainResource {
     /** High, low, normal, etc. */
     interpretation?: Array<CodeableConcept>;
     /** Healthcare event during which this observation is made */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     /** How it was done */
     method?: CodeableConcept;
     valueTime?: time;
     /** Specimen used for this observation */
-    specimen?: Reference<"Specimen">;
+    specimen?: Reference<'Specimen'>;
     _valueString?: Element;
     valueQuantity?: Quantity;
     valueString?: string;
@@ -55,7 +55,7 @@ export interface Observation extends DomainResource {
     valueSampledData?: SampledData;
     effectiveDateTime?: dateTime;
     /** registered | preliminary | final | amended + */
-    status: code;
+    status: `${ObservationStatus}`;
     _valueTime?: Element;
     /** Type of observation (code / type) */
     code: CodeableConcept;
@@ -72,7 +72,7 @@ export interface Observation extends DomainResource {
     issued?: instant;
     valuePeriod?: Period;
     /** (Measurement) Device */
-    device?: Reference<"Device" | "DeviceMetric">;
+    device?: Reference<'Device' | 'DeviceMetric'>;
     effectiveInstant?: instant;
     /** Fulfills plan, proposal or order */
     basedOn?: Array<Reference>;
@@ -81,7 +81,7 @@ export interface Observation extends DomainResource {
     partOf?: Array<Reference>;
     valueInteger?: integer;
     /** Who and/or what the observation is about */
-    subject?: Reference<"Patient" | "Device" | "Location" | "Group">;
+    subject?: Reference<'Patient' | 'Device' | 'Location' | 'Group'>;
     /** Who is responsible for the observation */
     performer?: Array<Reference>;
     /** Why the result is missing */
@@ -116,6 +116,17 @@ export interface ObservationComponent extends BackboneElement {
     dataAbsentReason?: CodeableConcept;
     _valueInteger?: Element;
 }
+/** registered | preliminary | final | amended + */
+export declare enum ObservationStatus {
+    Amended = "amended",
+    Cancelled = "cancelled",
+    Corrected = "corrected",
+    EnteredInError = "entered-in-error",
+    Final = "final",
+    Preliminary = "preliminary",
+    Registered = "registered",
+    Unknown = "unknown"
+}
 /** Provides guide for interpretation */
 export interface ObservationReferenceRange extends BackboneElement {
     /** Low Range, if relevant */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Observation.js b/vendor/r4/types/hl7-fhir-r4-core/Observation.js
index c8ad2e5..eb25877 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Observation.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Observation.js
@@ -1,2 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservationStatus = void 0;
+/** registered | preliminary | final | amended + */
+var ObservationStatus;
+(function (ObservationStatus) {
+    ObservationStatus["Amended"] = "amended";
+    ObservationStatus["Cancelled"] = "cancelled";
+    ObservationStatus["Corrected"] = "corrected";
+    ObservationStatus["EnteredInError"] = "entered-in-error";
+    ObservationStatus["Final"] = "final";
+    ObservationStatus["Preliminary"] = "preliminary";
+    ObservationStatus["Registered"] = "registered";
+    ObservationStatus["Unknown"] = "unknown";
+})(ObservationStatus = exports.ObservationStatus || (exports.ObservationStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ObservationDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ObservationDefinition.d.ts
index 33918fd..fee77d8 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ObservationDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ObservationDefinition.d.ts
@@ -12,6 +12,7 @@ import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service. */
 export interface ObservationDefinition extends DomainResource {
+    resourceType: 'ObservationDefinition';
     /** Characteristics of quantitative results */
     quantitativeDetails?: ObservationDefinitionQuantitativeDetails;
     /** Category of observation */
@@ -20,12 +21,12 @@ export interface ObservationDefinition extends DomainResource {
     method?: CodeableConcept;
     _multipleResultsAllowed?: Element;
     /** Value set of valid coded values for the observations conforming to this ObservationDefinition */
-    validCodedValueSet?: Reference<"ValueSet">;
+    validCodedValueSet?: Reference<'ValueSet'>;
     _preferredReportName?: Element;
     /** Qualified range for continuous and ordinal observation results */
     qualifiedInterval?: Array<ObservationDefinitionQualifiedInterval>;
     /** Value set of abnormal coded values for the observations conforming to this ObservationDefinition */
-    abnormalCodedValueSet?: Reference<"ValueSet">;
+    abnormalCodedValueSet?: Reference<'ValueSet'>;
     /** Type of observation (code / type) */
     code: CodeableConcept;
     /** Business identifier for this ObservationDefinition instance */
@@ -35,12 +36,12 @@ export interface ObservationDefinition extends DomainResource {
     /** Multiple results allowed */
     multipleResultsAllowed?: boolean;
     /** Value set of normal coded values for the observations conforming to this ObservationDefinition */
-    normalCodedValueSet?: Reference<"ValueSet">;
+    normalCodedValueSet?: Reference<'ValueSet'>;
     _permittedDataType?: Array<Element>;
     /** Preferred report name */
     preferredReportName?: string;
     /** Value set of critical coded values for the observations conforming to this ObservationDefinition */
-    criticalCodedValueSet?: Reference<"ValueSet">;
+    criticalCodedValueSet?: Reference<'ValueSet'>;
 }
 /** Characteristics of quantitative results */
 export interface ObservationDefinitionQuantitativeDetails extends BackboneElement {
@@ -55,10 +56,23 @@ export interface ObservationDefinitionQuantitativeDetails extends BackboneElemen
     decimalPrecision?: integer;
     _decimalPrecision?: Element;
 }
+/** reference | critical | absolute */
+export declare enum ObservationDefinitionCategory {
+    Absolute = "absolute",
+    Critical = "critical",
+    Reference = "reference"
+}
+/** male | female | other | unknown */
+export declare enum ObservationDefinitionGender {
+    Female = "female",
+    Male = "male",
+    Other = "other",
+    Unknown = "unknown"
+}
 /** Qualified range for continuous and ordinal observation results */
 export interface ObservationDefinitionQualifiedInterval extends BackboneElement {
     /** reference | critical | absolute */
-    category?: code;
+    category?: `${ObservationDefinitionCategory}`;
     /** Applicable age range, if relevant */
     age?: Range;
     /** Targetted population of the range */
@@ -72,7 +86,7 @@ export interface ObservationDefinitionQualifiedInterval extends BackboneElement
     /** Applicable gestational age range, if relevant */
     gestationalAge?: Range;
     /** male | female | other | unknown */
-    gender?: code;
+    gender?: `${ObservationDefinitionGender}`;
     _category?: Element;
     /** The interval itself, for continuous or ordinal observations */
     range?: Range;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ObservationDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/ObservationDefinition.js
index c8ad2e5..489f0e3 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ObservationDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ObservationDefinition.js
@@ -1,2 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservationDefinitionGender = exports.ObservationDefinitionCategory = void 0;
+/** reference | critical | absolute */
+var ObservationDefinitionCategory;
+(function (ObservationDefinitionCategory) {
+    ObservationDefinitionCategory["Absolute"] = "absolute";
+    ObservationDefinitionCategory["Critical"] = "critical";
+    ObservationDefinitionCategory["Reference"] = "reference";
+})(ObservationDefinitionCategory = exports.ObservationDefinitionCategory || (exports.ObservationDefinitionCategory = {}));
+/** male | female | other | unknown */
+var ObservationDefinitionGender;
+(function (ObservationDefinitionGender) {
+    ObservationDefinitionGender["Female"] = "female";
+    ObservationDefinitionGender["Male"] = "male";
+    ObservationDefinitionGender["Other"] = "other";
+    ObservationDefinitionGender["Unknown"] = "unknown";
+})(ObservationDefinitionGender = exports.ObservationDefinitionGender || (exports.ObservationDefinitionGender = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/OperationDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/OperationDefinition.d.ts
index eec2848..82e8c03 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/OperationDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/OperationDefinition.d.ts
@@ -14,6 +14,7 @@ import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction). */
 export interface OperationDefinition extends DomainResource {
+    resourceType: 'OperationDefinition';
     _base?: Element;
     /** Natural language description of the operation definition */
     description?: markdown;
@@ -55,13 +56,13 @@ export interface OperationDefinition extends DomainResource {
     _purpose?: Element;
     _resource?: Array<Element>;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${OperationDefinitionStatus}`;
     /** Types this operation applies to */
     resource?: Array<code>;
     /** Whether content is changed by the operation */
     affectsState?: boolean;
     /** operation | query */
-    kind: code;
+    kind: `${OperationDefinitionKind}`;
     /** Additional information about use */
     comment?: markdown;
     _name?: Element;
@@ -87,15 +88,6 @@ export interface OperationDefinition extends DomainResource {
     parameter?: Array<OperationDefinitionParameter>;
     _url?: Element;
 }
-/** Define overloaded variants for when  generating code */
-export interface OperationDefinitionOverload extends BackboneElement {
-    /** Name of parameter to include in overload */
-    parameterName?: Array<string>;
-    _parameterName?: Array<Element>;
-    /** Comments to go on overload */
-    comment?: string;
-    _comment?: Element;
-}
 /** References to this parameter */
 export interface OperationDefinitionParameterReferencedFrom extends BackboneElement {
     /** Referencing parameter */
@@ -108,12 +100,233 @@ export interface OperationDefinitionParameterReferencedFrom extends BackboneElem
 /** ValueSet details if this is coded */
 export interface OperationDefinitionParameterBinding extends BackboneElement {
     /** required | extensible | preferred | example */
-    strength: code;
+    strength: `${OperationDefinitionParameterStrength}`;
     _strength?: Element;
     /** Source of value set */
     valueSet: canonical;
     _valueSet?: Element;
 }
+/** What type this parameter has */
+export declare enum OperationDefinitionParameterType {
+    ImmunizationEvaluation = "ImmunizationEvaluation",
+    Appointment = "Appointment",
+    StructureMap = "StructureMap",
+    Address = "Address",
+    CareTeam = "CareTeam",
+    UsageContext = "UsageContext",
+    Linkage = "Linkage",
+    Annotation = "Annotation",
+    Age = "Age",
+    Attachment = "Attachment",
+    Communication = "Communication",
+    MedicationDispense = "MedicationDispense",
+    ImagingStudy = "ImagingStudy",
+    ChargeItem = "ChargeItem",
+    Period = "Period",
+    AdverseEvent = "AdverseEvent",
+    ContactDetail = "ContactDetail",
+    DataRequirement = "DataRequirement",
+    Media = "Media",
+    CodeableConcept = "CodeableConcept",
+    Uri = "uri",
+    SubstancePolymer = "SubstancePolymer",
+    QuestionnaireResponse = "QuestionnaireResponse",
+    Coverage = "Coverage",
+    Procedure = "Procedure",
+    AuditEvent = "AuditEvent",
+    PaymentReconciliation = "PaymentReconciliation",
+    MedicinalProductManufactured = "MedicinalProductManufactured",
+    CompartmentDefinition = "CompartmentDefinition",
+    Type = "Type",
+    Organization = "Organization",
+    ExplanationOfBenefit = "ExplanationOfBenefit",
+    Composition = "Composition",
+    SimpleQuantity = "SimpleQuantity",
+    CoverageEligibilityResponse = "CoverageEligibilityResponse",
+    DocumentReference = "DocumentReference",
+    EventDefinition = "EventDefinition",
+    SubstanceProtein = "SubstanceProtein",
+    TerminologyCapabilities = "TerminologyCapabilities",
+    Encounter = "Encounter",
+    ImplementationGuide = "ImplementationGuide",
+    EvidenceVariable = "EvidenceVariable",
+    ObservationDefinition = "ObservationDefinition",
+    DiagnosticReport = "DiagnosticReport",
+    ExampleScenario = "ExampleScenario",
+    ResearchDefinition = "ResearchDefinition",
+    Parameters = "Parameters",
+    Instant = "instant",
+    SearchParameter = "SearchParameter",
+    MedicinalProductInteraction = "MedicinalProductInteraction",
+    CodeSystem = "CodeSystem",
+    MessageDefinition = "MessageDefinition",
+    NutritionOrder = "NutritionOrder",
+    VerificationResult = "VerificationResult",
+    MedicationAdministration = "MedicationAdministration",
+    CatalogEntry = "CatalogEntry",
+    Flag = "Flag",
+    DeviceUseStatement = "DeviceUseStatement",
+    TriggerDefinition = "TriggerDefinition",
+    Contract = "Contract",
+    Invoice = "Invoice",
+    MarketingStatus = "MarketingStatus",
+    Count = "Count",
+    PaymentNotice = "PaymentNotice",
+    Location = "Location",
+    Claim = "Claim",
+    Specimen = "Specimen",
+    MedicationStatement = "MedicationStatement",
+    EnrollmentResponse = "EnrollmentResponse",
+    Uuid = "uuid",
+    Evidence = "Evidence",
+    Bundle = "Bundle",
+    ResearchElementDefinition = "ResearchElementDefinition",
+    Expression = "Expression",
+    Coding = "Coding",
+    BodyStructure = "BodyStructure",
+    MedicinalProduct = "MedicinalProduct",
+    Canonical = "canonical",
+    ResearchStudy = "ResearchStudy",
+    Dosage = "Dosage",
+    AppointmentResponse = "AppointmentResponse",
+    MedicinalProductIndication = "MedicinalProductIndication",
+    Measure = "Measure",
+    Person = "Person",
+    InsurancePlan = "InsurancePlan",
+    Date = "date",
+    Patient = "Patient",
+    EffectEvidenceSynthesis = "EffectEvidenceSynthesis",
+    ResearchSubject = "ResearchSubject",
+    Medication = "Medication",
+    Range = "Range",
+    ConceptMap = "ConceptMap",
+    CoverageEligibilityRequest = "CoverageEligibilityRequest",
+    Population = "Population",
+    SubstanceSourceMaterial = "SubstanceSourceMaterial",
+    VisionPrescription = "VisionPrescription",
+    MolecularSequence = "MolecularSequence",
+    MedicinalProductUndesirableEffect = "MedicinalProductUndesirableEffect",
+    OperationOutcome = "OperationOutcome",
+    MessageHeader = "MessageHeader",
+    ContactPoint = "ContactPoint",
+    Signature = "Signature",
+    Decimal = "decimal",
+    Any = "Any",
+    AllergyIntolerance = "AllergyIntolerance",
+    SubstanceReferenceInformation = "SubstanceReferenceInformation",
+    SupplyDelivery = "SupplyDelivery",
+    EpisodeOfCare = "EpisodeOfCare",
+    PractitionerRole = "PractitionerRole",
+    Library = "Library",
+    Practitioner = "Practitioner",
+    Markdown = "markdown",
+    MedicationRequest = "MedicationRequest",
+    ImmunizationRecommendation = "ImmunizationRecommendation",
+    RelatedArtifact = "RelatedArtifact",
+    Timing = "Timing",
+    Immunization = "Immunization",
+    GraphDefinition = "GraphDefinition",
+    Account = "Account",
+    Url = "url",
+    MedicinalProductIngredient = "MedicinalProductIngredient",
+    ProdCharacteristic = "ProdCharacteristic",
+    Meta = "Meta",
+    Quantity = "Quantity",
+    MeasureReport = "MeasureReport",
+    Distance = "Distance",
+    HumanName = "HumanName",
+    DeviceMetric = "DeviceMetric",
+    Duration = "Duration",
+    SubstanceAmount = "SubstanceAmount",
+    Goal = "Goal",
+    MedicationKnowledge = "MedicationKnowledge",
+    Integer = "integer",
+    String = "string",
+    ClaimResponse = "ClaimResponse",
+    DeviceDefinition = "DeviceDefinition",
+    Slot = "Slot",
+    ValueSet = "ValueSet",
+    MedicinalProductAuthorization = "MedicinalProductAuthorization",
+    StructureDefinition = "StructureDefinition",
+    Base64Binary = "base64Binary",
+    MedicinalProductContraindication = "MedicinalProductContraindication",
+    ElementDefinition = "ElementDefinition",
+    DeviceRequest = "DeviceRequest",
+    List = "List",
+    Questionnaire = "Questionnaire",
+    DomainResource = "DomainResource",
+    Endpoint = "Endpoint",
+    NamingSystem = "NamingSystem",
+    MedicinalProductPackaged = "MedicinalProductPackaged",
+    Basic = "Basic",
+    Money = "Money",
+    Binary = "Binary",
+    PlanDefinition = "PlanDefinition",
+    Subscription = "Subscription",
+    SampledData = "SampledData",
+    ProductShelfLife = "ProductShelfLife",
+    RelatedPerson = "RelatedPerson",
+    SubstanceSpecification = "SubstanceSpecification",
+    Ratio = "Ratio",
+    SubstanceNucleicAcid = "SubstanceNucleicAcid",
+    GuidanceResponse = "GuidanceResponse",
+    ClinicalImpression = "ClinicalImpression",
+    OrganizationAffiliation = "OrganizationAffiliation",
+    Resource = "Resource",
+    UnsignedInt = "unsignedInt",
+    Condition = "Condition",
+    Extension = "Extension",
+    CapabilityStatement = "CapabilityStatement",
+    HealthcareService = "HealthcareService",
+    SpecimenDefinition = "SpecimenDefinition",
+    ParameterDefinition = "ParameterDefinition",
+    RiskAssessment = "RiskAssessment",
+    Xhtml = "xhtml",
+    OperationDefinition = "OperationDefinition",
+    ActivityDefinition = "ActivityDefinition",
+    Schedule = "Schedule",
+    BiologicallyDerivedProduct = "BiologicallyDerivedProduct",
+    PositiveInt = "positiveInt",
+    Code = "code",
+    Group = "Group",
+    MedicinalProductPharmaceutical = "MedicinalProductPharmaceutical",
+    FamilyMemberHistory = "FamilyMemberHistory",
+    ServiceRequest = "ServiceRequest",
+    DetectedIssue = "DetectedIssue",
+    Device = "Device",
+    Oid = "oid",
+    RequestGroup = "RequestGroup",
+    TestScript = "TestScript",
+    RiskEvidenceSynthesis = "RiskEvidenceSynthesis",
+    SupplyRequest = "SupplyRequest",
+    Element = "Element",
+    Reference = "Reference",
+    Task = "Task",
+    Identifier = "Identifier",
+    CommunicationRequest = "CommunicationRequest",
+    EnrollmentRequest = "EnrollmentRequest",
+    ChargeItemDefinition = "ChargeItemDefinition",
+    Substance = "Substance",
+    Id = "id",
+    Provenance = "Provenance",
+    Time = "time",
+    Consent = "Consent",
+    BackboneElement = "BackboneElement",
+    CarePlan = "CarePlan",
+    Narrative = "Narrative",
+    MoneyQuantity = "MoneyQuantity",
+    TestReport = "TestReport",
+    Observation = "Observation",
+    DateTime = "dateTime",
+    Boolean = "boolean",
+    DocumentManifest = "DocumentManifest",
+    Contributor = "Contributor"
+}
+/** operation | query */
+export declare enum OperationDefinitionKind {
+    Operation = "operation",
+    Query = "query"
+}
 /** Parameters for the operation/query */
 export interface OperationDefinitionParameter extends BackboneElement {
     /** Minimum Cardinality */
@@ -121,16 +334,16 @@ export interface OperationDefinitionParameter extends BackboneElement {
     _documentation?: Element;
     _searchType?: Element;
     /** number | date | string | token | reference | composite | quantity | uri | special */
-    searchType?: code;
+    searchType?: `${OperationDefinitionParameterSearchType}`;
     /** in | out */
-    use: code;
+    use: `${OperationDefinitionParameterUse}`;
     /** Name in Parameters.parameter.name or in URL */
     name: code;
     /** Parts of a nested Parameter */
     part?: Array<OperationDefinitionParameter>;
     _type?: Element;
     /** What type this parameter has */
-    type?: code;
+    type?: `${OperationDefinitionParameterType}`;
     /** References to this parameter */
     referencedFrom?: Array<OperationDefinitionParameterReferencedFrom>;
     /** Description of meaning/use */
@@ -147,3 +360,43 @@ export interface OperationDefinitionParameter extends BackboneElement {
     _targetProfile?: Array<Element>;
     _use?: Element;
 }
+/** number | date | string | token | reference | composite | quantity | uri | special */
+export declare enum OperationDefinitionParameterSearchType {
+    Uri = "uri",
+    Number = "number",
+    Date = "date",
+    Special = "special",
+    Quantity = "quantity",
+    String = "string",
+    Composite = "composite",
+    Token = "token",
+    Reference = "reference"
+}
+/** Define overloaded variants for when  generating code */
+export interface OperationDefinitionOverload extends BackboneElement {
+    /** Name of parameter to include in overload */
+    parameterName?: Array<string>;
+    _parameterName?: Array<Element>;
+    /** Comments to go on overload */
+    comment?: string;
+    _comment?: Element;
+}
+/** required | extensible | preferred | example */
+export declare enum OperationDefinitionParameterStrength {
+    Example = "example",
+    Extensible = "extensible",
+    Preferred = "preferred",
+    Required = "required"
+}
+/** draft | active | retired | unknown */
+export declare enum OperationDefinitionStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** in | out */
+export declare enum OperationDefinitionParameterUse {
+    In = "in",
+    Out = "out"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/OperationDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/OperationDefinition.js
index c8ad2e5..f593f6c 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/OperationDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/OperationDefinition.js
@@ -1,2 +1,261 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationDefinitionParameterUse = exports.OperationDefinitionStatus = exports.OperationDefinitionParameterStrength = exports.OperationDefinitionParameterSearchType = exports.OperationDefinitionKind = exports.OperationDefinitionParameterType = void 0;
+/** What type this parameter has */
+var OperationDefinitionParameterType;
+(function (OperationDefinitionParameterType) {
+    OperationDefinitionParameterType["ImmunizationEvaluation"] = "ImmunizationEvaluation";
+    OperationDefinitionParameterType["Appointment"] = "Appointment";
+    OperationDefinitionParameterType["StructureMap"] = "StructureMap";
+    OperationDefinitionParameterType["Address"] = "Address";
+    OperationDefinitionParameterType["CareTeam"] = "CareTeam";
+    OperationDefinitionParameterType["UsageContext"] = "UsageContext";
+    OperationDefinitionParameterType["Linkage"] = "Linkage";
+    OperationDefinitionParameterType["Annotation"] = "Annotation";
+    OperationDefinitionParameterType["Age"] = "Age";
+    OperationDefinitionParameterType["Attachment"] = "Attachment";
+    OperationDefinitionParameterType["Communication"] = "Communication";
+    OperationDefinitionParameterType["MedicationDispense"] = "MedicationDispense";
+    OperationDefinitionParameterType["ImagingStudy"] = "ImagingStudy";
+    OperationDefinitionParameterType["ChargeItem"] = "ChargeItem";
+    OperationDefinitionParameterType["Period"] = "Period";
+    OperationDefinitionParameterType["AdverseEvent"] = "AdverseEvent";
+    OperationDefinitionParameterType["ContactDetail"] = "ContactDetail";
+    OperationDefinitionParameterType["DataRequirement"] = "DataRequirement";
+    OperationDefinitionParameterType["Media"] = "Media";
+    OperationDefinitionParameterType["CodeableConcept"] = "CodeableConcept";
+    OperationDefinitionParameterType["Uri"] = "uri";
+    OperationDefinitionParameterType["SubstancePolymer"] = "SubstancePolymer";
+    OperationDefinitionParameterType["QuestionnaireResponse"] = "QuestionnaireResponse";
+    OperationDefinitionParameterType["Coverage"] = "Coverage";
+    OperationDefinitionParameterType["Procedure"] = "Procedure";
+    OperationDefinitionParameterType["AuditEvent"] = "AuditEvent";
+    OperationDefinitionParameterType["PaymentReconciliation"] = "PaymentReconciliation";
+    OperationDefinitionParameterType["MedicinalProductManufactured"] = "MedicinalProductManufactured";
+    OperationDefinitionParameterType["CompartmentDefinition"] = "CompartmentDefinition";
+    OperationDefinitionParameterType["Type"] = "Type";
+    OperationDefinitionParameterType["Organization"] = "Organization";
+    OperationDefinitionParameterType["ExplanationOfBenefit"] = "ExplanationOfBenefit";
+    OperationDefinitionParameterType["Composition"] = "Composition";
+    OperationDefinitionParameterType["SimpleQuantity"] = "SimpleQuantity";
+    OperationDefinitionParameterType["CoverageEligibilityResponse"] = "CoverageEligibilityResponse";
+    OperationDefinitionParameterType["DocumentReference"] = "DocumentReference";
+    OperationDefinitionParameterType["EventDefinition"] = "EventDefinition";
+    OperationDefinitionParameterType["SubstanceProtein"] = "SubstanceProtein";
+    OperationDefinitionParameterType["TerminologyCapabilities"] = "TerminologyCapabilities";
+    OperationDefinitionParameterType["Encounter"] = "Encounter";
+    OperationDefinitionParameterType["ImplementationGuide"] = "ImplementationGuide";
+    OperationDefinitionParameterType["EvidenceVariable"] = "EvidenceVariable";
+    OperationDefinitionParameterType["ObservationDefinition"] = "ObservationDefinition";
+    OperationDefinitionParameterType["DiagnosticReport"] = "DiagnosticReport";
+    OperationDefinitionParameterType["ExampleScenario"] = "ExampleScenario";
+    OperationDefinitionParameterType["ResearchDefinition"] = "ResearchDefinition";
+    OperationDefinitionParameterType["Parameters"] = "Parameters";
+    OperationDefinitionParameterType["Instant"] = "instant";
+    OperationDefinitionParameterType["SearchParameter"] = "SearchParameter";
+    OperationDefinitionParameterType["MedicinalProductInteraction"] = "MedicinalProductInteraction";
+    OperationDefinitionParameterType["CodeSystem"] = "CodeSystem";
+    OperationDefinitionParameterType["MessageDefinition"] = "MessageDefinition";
+    OperationDefinitionParameterType["NutritionOrder"] = "NutritionOrder";
+    OperationDefinitionParameterType["VerificationResult"] = "VerificationResult";
+    OperationDefinitionParameterType["MedicationAdministration"] = "MedicationAdministration";
+    OperationDefinitionParameterType["CatalogEntry"] = "CatalogEntry";
+    OperationDefinitionParameterType["Flag"] = "Flag";
+    OperationDefinitionParameterType["DeviceUseStatement"] = "DeviceUseStatement";
+    OperationDefinitionParameterType["TriggerDefinition"] = "TriggerDefinition";
+    OperationDefinitionParameterType["Contract"] = "Contract";
+    OperationDefinitionParameterType["Invoice"] = "Invoice";
+    OperationDefinitionParameterType["MarketingStatus"] = "MarketingStatus";
+    OperationDefinitionParameterType["Count"] = "Count";
+    OperationDefinitionParameterType["PaymentNotice"] = "PaymentNotice";
+    OperationDefinitionParameterType["Location"] = "Location";
+    OperationDefinitionParameterType["Claim"] = "Claim";
+    OperationDefinitionParameterType["Specimen"] = "Specimen";
+    OperationDefinitionParameterType["MedicationStatement"] = "MedicationStatement";
+    OperationDefinitionParameterType["EnrollmentResponse"] = "EnrollmentResponse";
+    OperationDefinitionParameterType["Uuid"] = "uuid";
+    OperationDefinitionParameterType["Evidence"] = "Evidence";
+    OperationDefinitionParameterType["Bundle"] = "Bundle";
+    OperationDefinitionParameterType["ResearchElementDefinition"] = "ResearchElementDefinition";
+    OperationDefinitionParameterType["Expression"] = "Expression";
+    OperationDefinitionParameterType["Coding"] = "Coding";
+    OperationDefinitionParameterType["BodyStructure"] = "BodyStructure";
+    OperationDefinitionParameterType["MedicinalProduct"] = "MedicinalProduct";
+    OperationDefinitionParameterType["Canonical"] = "canonical";
+    OperationDefinitionParameterType["ResearchStudy"] = "ResearchStudy";
+    OperationDefinitionParameterType["Dosage"] = "Dosage";
+    OperationDefinitionParameterType["AppointmentResponse"] = "AppointmentResponse";
+    OperationDefinitionParameterType["MedicinalProductIndication"] = "MedicinalProductIndication";
+    OperationDefinitionParameterType["Measure"] = "Measure";
+    OperationDefinitionParameterType["Person"] = "Person";
+    OperationDefinitionParameterType["InsurancePlan"] = "InsurancePlan";
+    OperationDefinitionParameterType["Date"] = "date";
+    OperationDefinitionParameterType["Patient"] = "Patient";
+    OperationDefinitionParameterType["EffectEvidenceSynthesis"] = "EffectEvidenceSynthesis";
+    OperationDefinitionParameterType["ResearchSubject"] = "ResearchSubject";
+    OperationDefinitionParameterType["Medication"] = "Medication";
+    OperationDefinitionParameterType["Range"] = "Range";
+    OperationDefinitionParameterType["ConceptMap"] = "ConceptMap";
+    OperationDefinitionParameterType["CoverageEligibilityRequest"] = "CoverageEligibilityRequest";
+    OperationDefinitionParameterType["Population"] = "Population";
+    OperationDefinitionParameterType["SubstanceSourceMaterial"] = "SubstanceSourceMaterial";
+    OperationDefinitionParameterType["VisionPrescription"] = "VisionPrescription";
+    OperationDefinitionParameterType["MolecularSequence"] = "MolecularSequence";
+    OperationDefinitionParameterType["MedicinalProductUndesirableEffect"] = "MedicinalProductUndesirableEffect";
+    OperationDefinitionParameterType["OperationOutcome"] = "OperationOutcome";
+    OperationDefinitionParameterType["MessageHeader"] = "MessageHeader";
+    OperationDefinitionParameterType["ContactPoint"] = "ContactPoint";
+    OperationDefinitionParameterType["Signature"] = "Signature";
+    OperationDefinitionParameterType["Decimal"] = "decimal";
+    OperationDefinitionParameterType["Any"] = "Any";
+    OperationDefinitionParameterType["AllergyIntolerance"] = "AllergyIntolerance";
+    OperationDefinitionParameterType["SubstanceReferenceInformation"] = "SubstanceReferenceInformation";
+    OperationDefinitionParameterType["SupplyDelivery"] = "SupplyDelivery";
+    OperationDefinitionParameterType["EpisodeOfCare"] = "EpisodeOfCare";
+    OperationDefinitionParameterType["PractitionerRole"] = "PractitionerRole";
+    OperationDefinitionParameterType["Library"] = "Library";
+    OperationDefinitionParameterType["Practitioner"] = "Practitioner";
+    OperationDefinitionParameterType["Markdown"] = "markdown";
+    OperationDefinitionParameterType["MedicationRequest"] = "MedicationRequest";
+    OperationDefinitionParameterType["ImmunizationRecommendation"] = "ImmunizationRecommendation";
+    OperationDefinitionParameterType["RelatedArtifact"] = "RelatedArtifact";
+    OperationDefinitionParameterType["Timing"] = "Timing";
+    OperationDefinitionParameterType["Immunization"] = "Immunization";
+    OperationDefinitionParameterType["GraphDefinition"] = "GraphDefinition";
+    OperationDefinitionParameterType["Account"] = "Account";
+    OperationDefinitionParameterType["Url"] = "url";
+    OperationDefinitionParameterType["MedicinalProductIngredient"] = "MedicinalProductIngredient";
+    OperationDefinitionParameterType["ProdCharacteristic"] = "ProdCharacteristic";
+    OperationDefinitionParameterType["Meta"] = "Meta";
+    OperationDefinitionParameterType["Quantity"] = "Quantity";
+    OperationDefinitionParameterType["MeasureReport"] = "MeasureReport";
+    OperationDefinitionParameterType["Distance"] = "Distance";
+    OperationDefinitionParameterType["HumanName"] = "HumanName";
+    OperationDefinitionParameterType["DeviceMetric"] = "DeviceMetric";
+    OperationDefinitionParameterType["Duration"] = "Duration";
+    OperationDefinitionParameterType["SubstanceAmount"] = "SubstanceAmount";
+    OperationDefinitionParameterType["Goal"] = "Goal";
+    OperationDefinitionParameterType["MedicationKnowledge"] = "MedicationKnowledge";
+    OperationDefinitionParameterType["Integer"] = "integer";
+    OperationDefinitionParameterType["String"] = "string";
+    OperationDefinitionParameterType["ClaimResponse"] = "ClaimResponse";
+    OperationDefinitionParameterType["DeviceDefinition"] = "DeviceDefinition";
+    OperationDefinitionParameterType["Slot"] = "Slot";
+    OperationDefinitionParameterType["ValueSet"] = "ValueSet";
+    OperationDefinitionParameterType["MedicinalProductAuthorization"] = "MedicinalProductAuthorization";
+    OperationDefinitionParameterType["StructureDefinition"] = "StructureDefinition";
+    OperationDefinitionParameterType["Base64Binary"] = "base64Binary";
+    OperationDefinitionParameterType["MedicinalProductContraindication"] = "MedicinalProductContraindication";
+    OperationDefinitionParameterType["ElementDefinition"] = "ElementDefinition";
+    OperationDefinitionParameterType["DeviceRequest"] = "DeviceRequest";
+    OperationDefinitionParameterType["List"] = "List";
+    OperationDefinitionParameterType["Questionnaire"] = "Questionnaire";
+    OperationDefinitionParameterType["DomainResource"] = "DomainResource";
+    OperationDefinitionParameterType["Endpoint"] = "Endpoint";
+    OperationDefinitionParameterType["NamingSystem"] = "NamingSystem";
+    OperationDefinitionParameterType["MedicinalProductPackaged"] = "MedicinalProductPackaged";
+    OperationDefinitionParameterType["Basic"] = "Basic";
+    OperationDefinitionParameterType["Money"] = "Money";
+    OperationDefinitionParameterType["Binary"] = "Binary";
+    OperationDefinitionParameterType["PlanDefinition"] = "PlanDefinition";
+    OperationDefinitionParameterType["Subscription"] = "Subscription";
+    OperationDefinitionParameterType["SampledData"] = "SampledData";
+    OperationDefinitionParameterType["ProductShelfLife"] = "ProductShelfLife";
+    OperationDefinitionParameterType["RelatedPerson"] = "RelatedPerson";
+    OperationDefinitionParameterType["SubstanceSpecification"] = "SubstanceSpecification";
+    OperationDefinitionParameterType["Ratio"] = "Ratio";
+    OperationDefinitionParameterType["SubstanceNucleicAcid"] = "SubstanceNucleicAcid";
+    OperationDefinitionParameterType["GuidanceResponse"] = "GuidanceResponse";
+    OperationDefinitionParameterType["ClinicalImpression"] = "ClinicalImpression";
+    OperationDefinitionParameterType["OrganizationAffiliation"] = "OrganizationAffiliation";
+    OperationDefinitionParameterType["Resource"] = "Resource";
+    OperationDefinitionParameterType["UnsignedInt"] = "unsignedInt";
+    OperationDefinitionParameterType["Condition"] = "Condition";
+    OperationDefinitionParameterType["Extension"] = "Extension";
+    OperationDefinitionParameterType["CapabilityStatement"] = "CapabilityStatement";
+    OperationDefinitionParameterType["HealthcareService"] = "HealthcareService";
+    OperationDefinitionParameterType["SpecimenDefinition"] = "SpecimenDefinition";
+    OperationDefinitionParameterType["ParameterDefinition"] = "ParameterDefinition";
+    OperationDefinitionParameterType["RiskAssessment"] = "RiskAssessment";
+    OperationDefinitionParameterType["Xhtml"] = "xhtml";
+    OperationDefinitionParameterType["OperationDefinition"] = "OperationDefinition";
+    OperationDefinitionParameterType["ActivityDefinition"] = "ActivityDefinition";
+    OperationDefinitionParameterType["Schedule"] = "Schedule";
+    OperationDefinitionParameterType["BiologicallyDerivedProduct"] = "BiologicallyDerivedProduct";
+    OperationDefinitionParameterType["PositiveInt"] = "positiveInt";
+    OperationDefinitionParameterType["Code"] = "code";
+    OperationDefinitionParameterType["Group"] = "Group";
+    OperationDefinitionParameterType["MedicinalProductPharmaceutical"] = "MedicinalProductPharmaceutical";
+    OperationDefinitionParameterType["FamilyMemberHistory"] = "FamilyMemberHistory";
+    OperationDefinitionParameterType["ServiceRequest"] = "ServiceRequest";
+    OperationDefinitionParameterType["DetectedIssue"] = "DetectedIssue";
+    OperationDefinitionParameterType["Device"] = "Device";
+    OperationDefinitionParameterType["Oid"] = "oid";
+    OperationDefinitionParameterType["RequestGroup"] = "RequestGroup";
+    OperationDefinitionParameterType["TestScript"] = "TestScript";
+    OperationDefinitionParameterType["RiskEvidenceSynthesis"] = "RiskEvidenceSynthesis";
+    OperationDefinitionParameterType["SupplyRequest"] = "SupplyRequest";
+    OperationDefinitionParameterType["Element"] = "Element";
+    OperationDefinitionParameterType["Reference"] = "Reference";
+    OperationDefinitionParameterType["Task"] = "Task";
+    OperationDefinitionParameterType["Identifier"] = "Identifier";
+    OperationDefinitionParameterType["CommunicationRequest"] = "CommunicationRequest";
+    OperationDefinitionParameterType["EnrollmentRequest"] = "EnrollmentRequest";
+    OperationDefinitionParameterType["ChargeItemDefinition"] = "ChargeItemDefinition";
+    OperationDefinitionParameterType["Substance"] = "Substance";
+    OperationDefinitionParameterType["Id"] = "id";
+    OperationDefinitionParameterType["Provenance"] = "Provenance";
+    OperationDefinitionParameterType["Time"] = "time";
+    OperationDefinitionParameterType["Consent"] = "Consent";
+    OperationDefinitionParameterType["BackboneElement"] = "BackboneElement";
+    OperationDefinitionParameterType["CarePlan"] = "CarePlan";
+    OperationDefinitionParameterType["Narrative"] = "Narrative";
+    OperationDefinitionParameterType["MoneyQuantity"] = "MoneyQuantity";
+    OperationDefinitionParameterType["TestReport"] = "TestReport";
+    OperationDefinitionParameterType["Observation"] = "Observation";
+    OperationDefinitionParameterType["DateTime"] = "dateTime";
+    OperationDefinitionParameterType["Boolean"] = "boolean";
+    OperationDefinitionParameterType["DocumentManifest"] = "DocumentManifest";
+    OperationDefinitionParameterType["Contributor"] = "Contributor";
+})(OperationDefinitionParameterType = exports.OperationDefinitionParameterType || (exports.OperationDefinitionParameterType = {}));
+/** operation | query */
+var OperationDefinitionKind;
+(function (OperationDefinitionKind) {
+    OperationDefinitionKind["Operation"] = "operation";
+    OperationDefinitionKind["Query"] = "query";
+})(OperationDefinitionKind = exports.OperationDefinitionKind || (exports.OperationDefinitionKind = {}));
+/** number | date | string | token | reference | composite | quantity | uri | special */
+var OperationDefinitionParameterSearchType;
+(function (OperationDefinitionParameterSearchType) {
+    OperationDefinitionParameterSearchType["Uri"] = "uri";
+    OperationDefinitionParameterSearchType["Number"] = "number";
+    OperationDefinitionParameterSearchType["Date"] = "date";
+    OperationDefinitionParameterSearchType["Special"] = "special";
+    OperationDefinitionParameterSearchType["Quantity"] = "quantity";
+    OperationDefinitionParameterSearchType["String"] = "string";
+    OperationDefinitionParameterSearchType["Composite"] = "composite";
+    OperationDefinitionParameterSearchType["Token"] = "token";
+    OperationDefinitionParameterSearchType["Reference"] = "reference";
+})(OperationDefinitionParameterSearchType = exports.OperationDefinitionParameterSearchType || (exports.OperationDefinitionParameterSearchType = {}));
+/** required | extensible | preferred | example */
+var OperationDefinitionParameterStrength;
+(function (OperationDefinitionParameterStrength) {
+    OperationDefinitionParameterStrength["Example"] = "example";
+    OperationDefinitionParameterStrength["Extensible"] = "extensible";
+    OperationDefinitionParameterStrength["Preferred"] = "preferred";
+    OperationDefinitionParameterStrength["Required"] = "required";
+})(OperationDefinitionParameterStrength = exports.OperationDefinitionParameterStrength || (exports.OperationDefinitionParameterStrength = {}));
+/** draft | active | retired | unknown */
+var OperationDefinitionStatus;
+(function (OperationDefinitionStatus) {
+    OperationDefinitionStatus["Active"] = "active";
+    OperationDefinitionStatus["Draft"] = "draft";
+    OperationDefinitionStatus["Retired"] = "retired";
+    OperationDefinitionStatus["Unknown"] = "unknown";
+})(OperationDefinitionStatus = exports.OperationDefinitionStatus || (exports.OperationDefinitionStatus = {}));
+/** in | out */
+var OperationDefinitionParameterUse;
+(function (OperationDefinitionParameterUse) {
+    OperationDefinitionParameterUse["In"] = "in";
+    OperationDefinitionParameterUse["Out"] = "out";
+})(OperationDefinitionParameterUse = exports.OperationDefinitionParameterUse || (exports.OperationDefinitionParameterUse = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/OperationOutcome.d.ts b/vendor/r4/types/hl7-fhir-r4-core/OperationOutcome.d.ts
index fe6d9d4..9a75244 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/OperationOutcome.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/OperationOutcome.d.ts
@@ -3,13 +3,54 @@ DON'T MODIFY MANUALLY */
 import { CodeableConcept } from "./CodeableConcept";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
-import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** A collection of error, warning, or information messages that result from a system action. */
 export interface OperationOutcome extends DomainResource {
+    resourceType: 'OperationOutcome';
     /** A single issue associated with the action */
     issue: Array<OperationOutcomeIssue>;
 }
+/** fatal | error | warning | information */
+export declare enum OperationOutcomeSeverity {
+    Error = "error",
+    Fatal = "fatal",
+    Information = "information",
+    Warning = "warning"
+}
+/** Error or warning code */
+export declare enum OperationOutcomeCode {
+    Transient = "transient",
+    Suppressed = "suppressed",
+    NotFound = "not-found",
+    NotSupported = "not-supported",
+    Timeout = "timeout",
+    Invalid = "invalid",
+    TooCostly = "too-costly",
+    Login = "login",
+    Throttled = "throttled",
+    Conflict = "conflict",
+    MultipleMatches = "multiple-matches",
+    Unknown = "unknown",
+    Expired = "expired",
+    Incomplete = "incomplete",
+    Security = "security",
+    Value = "value",
+    NoStore = "no-store",
+    TooLong = "too-long",
+    Required = "required",
+    BusinessRule = "business-rule",
+    Deleted = "deleted",
+    Processing = "processing",
+    CodeInvalid = "code-invalid",
+    Invariant = "invariant",
+    Duplicate = "duplicate",
+    Extension = "extension",
+    Forbidden = "forbidden",
+    Structure = "structure",
+    Informational = "informational",
+    Exception = "exception",
+    LockError = "lock-error"
+}
 /** A single issue associated with the action */
 export interface OperationOutcomeIssue extends BackboneElement {
     _code?: Element;
@@ -22,9 +63,9 @@ export interface OperationOutcomeIssue extends BackboneElement {
     /** Additional details about the error */
     details?: CodeableConcept;
     /** fatal | error | warning | information */
-    severity: code;
+    severity: `${OperationOutcomeSeverity}`;
     /** Error or warning code */
-    code: code;
+    code: `${OperationOutcomeCode}`;
     _severity?: Element;
     /** Deprecated: Path of element(s) related to issue */
     location?: Array<string>;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/OperationOutcome.js b/vendor/r4/types/hl7-fhir-r4-core/OperationOutcome.js
index c8ad2e5..12c6c42 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/OperationOutcome.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/OperationOutcome.js
@@ -1,2 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationOutcomeCode = exports.OperationOutcomeSeverity = void 0;
+/** fatal | error | warning | information */
+var OperationOutcomeSeverity;
+(function (OperationOutcomeSeverity) {
+    OperationOutcomeSeverity["Error"] = "error";
+    OperationOutcomeSeverity["Fatal"] = "fatal";
+    OperationOutcomeSeverity["Information"] = "information";
+    OperationOutcomeSeverity["Warning"] = "warning";
+})(OperationOutcomeSeverity = exports.OperationOutcomeSeverity || (exports.OperationOutcomeSeverity = {}));
+/** Error or warning code */
+var OperationOutcomeCode;
+(function (OperationOutcomeCode) {
+    OperationOutcomeCode["Transient"] = "transient";
+    OperationOutcomeCode["Suppressed"] = "suppressed";
+    OperationOutcomeCode["NotFound"] = "not-found";
+    OperationOutcomeCode["NotSupported"] = "not-supported";
+    OperationOutcomeCode["Timeout"] = "timeout";
+    OperationOutcomeCode["Invalid"] = "invalid";
+    OperationOutcomeCode["TooCostly"] = "too-costly";
+    OperationOutcomeCode["Login"] = "login";
+    OperationOutcomeCode["Throttled"] = "throttled";
+    OperationOutcomeCode["Conflict"] = "conflict";
+    OperationOutcomeCode["MultipleMatches"] = "multiple-matches";
+    OperationOutcomeCode["Unknown"] = "unknown";
+    OperationOutcomeCode["Expired"] = "expired";
+    OperationOutcomeCode["Incomplete"] = "incomplete";
+    OperationOutcomeCode["Security"] = "security";
+    OperationOutcomeCode["Value"] = "value";
+    OperationOutcomeCode["NoStore"] = "no-store";
+    OperationOutcomeCode["TooLong"] = "too-long";
+    OperationOutcomeCode["Required"] = "required";
+    OperationOutcomeCode["BusinessRule"] = "business-rule";
+    OperationOutcomeCode["Deleted"] = "deleted";
+    OperationOutcomeCode["Processing"] = "processing";
+    OperationOutcomeCode["CodeInvalid"] = "code-invalid";
+    OperationOutcomeCode["Invariant"] = "invariant";
+    OperationOutcomeCode["Duplicate"] = "duplicate";
+    OperationOutcomeCode["Extension"] = "extension";
+    OperationOutcomeCode["Forbidden"] = "forbidden";
+    OperationOutcomeCode["Structure"] = "structure";
+    OperationOutcomeCode["Informational"] = "informational";
+    OperationOutcomeCode["Exception"] = "exception";
+    OperationOutcomeCode["LockError"] = "lock-error";
+})(OperationOutcomeCode = exports.OperationOutcomeCode || (exports.OperationOutcomeCode = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Organization.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Organization.d.ts
index 79e6f26..3b24e05 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Organization.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Organization.d.ts
@@ -11,6 +11,7 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action.  Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc. */
 export interface Organization extends DomainResource {
+    resourceType: 'Organization';
     _active?: Element;
     /** An address for the organization */
     address?: Array<Address>;
@@ -28,7 +29,7 @@ export interface Organization extends DomainResource {
     /** A contact detail for the organization */
     telecom?: Array<ContactPoint>;
     /** The organization of which this organization forms a part */
-    partOf?: Reference<"Organization">;
+    partOf?: Reference<'Organization'>;
     _alias?: Array<Element>;
     /** Technical endpoints providing access to services operated for the organization */
     endpoint?: Array<Reference>;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/OrganizationAffiliation.d.ts b/vendor/r4/types/hl7-fhir-r4-core/OrganizationAffiliation.d.ts
index 8a796c3..f9898ad 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/OrganizationAffiliation.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/OrganizationAffiliation.d.ts
@@ -9,13 +9,14 @@ import { Reference } from "./Reference";
 import { Identifier } from "./Identifier";
 /** Defines an affiliation/assotiation/relationship between 2 distinct oganizations, that is not a part-of relationship/sub-division relationship. */
 export interface OrganizationAffiliation extends DomainResource {
+    resourceType: 'OrganizationAffiliation';
     _active?: Element;
     /** Specific specialty of the participatingOrganization in the context of the role */
     specialty?: Array<CodeableConcept>;
     /** Organization where the role is available */
-    organization?: Reference<"Organization">;
+    organization?: Reference<'Organization'>;
     /** Organization that provides/performs the role (e.g. providing services or is a member of) */
-    participatingOrganization?: Reference<"Organization">;
+    participatingOrganization?: Reference<'Organization'>;
     /** Whether this organization affiliation record is in active use */
     active?: boolean;
     /** Definition of the role the participatingOrganization plays */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ParameterDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ParameterDefinition.d.ts
index 394e101..8d74abe 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ParameterDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ParameterDefinition.d.ts
@@ -10,12 +10,12 @@ export interface ParameterDefinition extends Element {
     min?: integer;
     _documentation?: Element;
     /** in | out */
-    use: code;
+    use: `${ParameterDefinitionUse}`;
     /** Name used to access the parameter value */
     name?: code;
     _type?: Element;
     /** What type of value */
-    type: code;
+    type: `${ParameterDefinitionType}`;
     /** A brief description of the parameter */
     documentation?: string;
     _profile?: Element;
@@ -28,3 +28,224 @@ export interface ParameterDefinition extends Element {
     /** What profile the value is expected to be */
     profile?: canonical;
 }
+/** in | out */
+export declare enum ParameterDefinitionUse {
+    In = "in",
+    Out = "out"
+}
+/** What type of value */
+export declare enum ParameterDefinitionType {
+    ImmunizationEvaluation = "ImmunizationEvaluation",
+    Appointment = "Appointment",
+    StructureMap = "StructureMap",
+    Address = "Address",
+    CareTeam = "CareTeam",
+    UsageContext = "UsageContext",
+    Linkage = "Linkage",
+    Annotation = "Annotation",
+    Age = "Age",
+    Attachment = "Attachment",
+    Communication = "Communication",
+    MedicationDispense = "MedicationDispense",
+    ImagingStudy = "ImagingStudy",
+    ChargeItem = "ChargeItem",
+    Period = "Period",
+    AdverseEvent = "AdverseEvent",
+    ContactDetail = "ContactDetail",
+    DataRequirement = "DataRequirement",
+    Media = "Media",
+    CodeableConcept = "CodeableConcept",
+    Uri = "uri",
+    SubstancePolymer = "SubstancePolymer",
+    QuestionnaireResponse = "QuestionnaireResponse",
+    Coverage = "Coverage",
+    Procedure = "Procedure",
+    AuditEvent = "AuditEvent",
+    PaymentReconciliation = "PaymentReconciliation",
+    MedicinalProductManufactured = "MedicinalProductManufactured",
+    CompartmentDefinition = "CompartmentDefinition",
+    Type = "Type",
+    Organization = "Organization",
+    ExplanationOfBenefit = "ExplanationOfBenefit",
+    Composition = "Composition",
+    SimpleQuantity = "SimpleQuantity",
+    CoverageEligibilityResponse = "CoverageEligibilityResponse",
+    DocumentReference = "DocumentReference",
+    EventDefinition = "EventDefinition",
+    SubstanceProtein = "SubstanceProtein",
+    TerminologyCapabilities = "TerminologyCapabilities",
+    Encounter = "Encounter",
+    ImplementationGuide = "ImplementationGuide",
+    EvidenceVariable = "EvidenceVariable",
+    ObservationDefinition = "ObservationDefinition",
+    DiagnosticReport = "DiagnosticReport",
+    ExampleScenario = "ExampleScenario",
+    ResearchDefinition = "ResearchDefinition",
+    Parameters = "Parameters",
+    Instant = "instant",
+    SearchParameter = "SearchParameter",
+    MedicinalProductInteraction = "MedicinalProductInteraction",
+    CodeSystem = "CodeSystem",
+    MessageDefinition = "MessageDefinition",
+    NutritionOrder = "NutritionOrder",
+    VerificationResult = "VerificationResult",
+    MedicationAdministration = "MedicationAdministration",
+    CatalogEntry = "CatalogEntry",
+    Flag = "Flag",
+    DeviceUseStatement = "DeviceUseStatement",
+    TriggerDefinition = "TriggerDefinition",
+    Contract = "Contract",
+    Invoice = "Invoice",
+    MarketingStatus = "MarketingStatus",
+    Count = "Count",
+    PaymentNotice = "PaymentNotice",
+    Location = "Location",
+    Claim = "Claim",
+    Specimen = "Specimen",
+    MedicationStatement = "MedicationStatement",
+    EnrollmentResponse = "EnrollmentResponse",
+    Uuid = "uuid",
+    Evidence = "Evidence",
+    Bundle = "Bundle",
+    ResearchElementDefinition = "ResearchElementDefinition",
+    Expression = "Expression",
+    Coding = "Coding",
+    BodyStructure = "BodyStructure",
+    MedicinalProduct = "MedicinalProduct",
+    Canonical = "canonical",
+    ResearchStudy = "ResearchStudy",
+    Dosage = "Dosage",
+    AppointmentResponse = "AppointmentResponse",
+    MedicinalProductIndication = "MedicinalProductIndication",
+    Measure = "Measure",
+    Person = "Person",
+    InsurancePlan = "InsurancePlan",
+    Date = "date",
+    Patient = "Patient",
+    EffectEvidenceSynthesis = "EffectEvidenceSynthesis",
+    ResearchSubject = "ResearchSubject",
+    Medication = "Medication",
+    Range = "Range",
+    ConceptMap = "ConceptMap",
+    CoverageEligibilityRequest = "CoverageEligibilityRequest",
+    Population = "Population",
+    SubstanceSourceMaterial = "SubstanceSourceMaterial",
+    VisionPrescription = "VisionPrescription",
+    MolecularSequence = "MolecularSequence",
+    MedicinalProductUndesirableEffect = "MedicinalProductUndesirableEffect",
+    OperationOutcome = "OperationOutcome",
+    MessageHeader = "MessageHeader",
+    ContactPoint = "ContactPoint",
+    Signature = "Signature",
+    Decimal = "decimal",
+    Any = "Any",
+    AllergyIntolerance = "AllergyIntolerance",
+    SubstanceReferenceInformation = "SubstanceReferenceInformation",
+    SupplyDelivery = "SupplyDelivery",
+    EpisodeOfCare = "EpisodeOfCare",
+    PractitionerRole = "PractitionerRole",
+    Library = "Library",
+    Practitioner = "Practitioner",
+    Markdown = "markdown",
+    MedicationRequest = "MedicationRequest",
+    ImmunizationRecommendation = "ImmunizationRecommendation",
+    RelatedArtifact = "RelatedArtifact",
+    Timing = "Timing",
+    Immunization = "Immunization",
+    GraphDefinition = "GraphDefinition",
+    Account = "Account",
+    Url = "url",
+    MedicinalProductIngredient = "MedicinalProductIngredient",
+    ProdCharacteristic = "ProdCharacteristic",
+    Meta = "Meta",
+    Quantity = "Quantity",
+    MeasureReport = "MeasureReport",
+    Distance = "Distance",
+    HumanName = "HumanName",
+    DeviceMetric = "DeviceMetric",
+    Duration = "Duration",
+    SubstanceAmount = "SubstanceAmount",
+    Goal = "Goal",
+    MedicationKnowledge = "MedicationKnowledge",
+    Integer = "integer",
+    String = "string",
+    ClaimResponse = "ClaimResponse",
+    DeviceDefinition = "DeviceDefinition",
+    Slot = "Slot",
+    ValueSet = "ValueSet",
+    MedicinalProductAuthorization = "MedicinalProductAuthorization",
+    StructureDefinition = "StructureDefinition",
+    Base64Binary = "base64Binary",
+    MedicinalProductContraindication = "MedicinalProductContraindication",
+    ElementDefinition = "ElementDefinition",
+    DeviceRequest = "DeviceRequest",
+    List = "List",
+    Questionnaire = "Questionnaire",
+    DomainResource = "DomainResource",
+    Endpoint = "Endpoint",
+    NamingSystem = "NamingSystem",
+    MedicinalProductPackaged = "MedicinalProductPackaged",
+    Basic = "Basic",
+    Money = "Money",
+    Binary = "Binary",
+    PlanDefinition = "PlanDefinition",
+    Subscription = "Subscription",
+    SampledData = "SampledData",
+    ProductShelfLife = "ProductShelfLife",
+    RelatedPerson = "RelatedPerson",
+    SubstanceSpecification = "SubstanceSpecification",
+    Ratio = "Ratio",
+    SubstanceNucleicAcid = "SubstanceNucleicAcid",
+    GuidanceResponse = "GuidanceResponse",
+    ClinicalImpression = "ClinicalImpression",
+    OrganizationAffiliation = "OrganizationAffiliation",
+    Resource = "Resource",
+    UnsignedInt = "unsignedInt",
+    Condition = "Condition",
+    Extension = "Extension",
+    CapabilityStatement = "CapabilityStatement",
+    HealthcareService = "HealthcareService",
+    SpecimenDefinition = "SpecimenDefinition",
+    ParameterDefinition = "ParameterDefinition",
+    RiskAssessment = "RiskAssessment",
+    Xhtml = "xhtml",
+    OperationDefinition = "OperationDefinition",
+    ActivityDefinition = "ActivityDefinition",
+    Schedule = "Schedule",
+    BiologicallyDerivedProduct = "BiologicallyDerivedProduct",
+    PositiveInt = "positiveInt",
+    Code = "code",
+    Group = "Group",
+    MedicinalProductPharmaceutical = "MedicinalProductPharmaceutical",
+    FamilyMemberHistory = "FamilyMemberHistory",
+    ServiceRequest = "ServiceRequest",
+    DetectedIssue = "DetectedIssue",
+    Device = "Device",
+    Oid = "oid",
+    RequestGroup = "RequestGroup",
+    TestScript = "TestScript",
+    RiskEvidenceSynthesis = "RiskEvidenceSynthesis",
+    SupplyRequest = "SupplyRequest",
+    Element = "Element",
+    Reference = "Reference",
+    Task = "Task",
+    Identifier = "Identifier",
+    CommunicationRequest = "CommunicationRequest",
+    EnrollmentRequest = "EnrollmentRequest",
+    ChargeItemDefinition = "ChargeItemDefinition",
+    Substance = "Substance",
+    Id = "id",
+    Provenance = "Provenance",
+    Time = "time",
+    Consent = "Consent",
+    BackboneElement = "BackboneElement",
+    CarePlan = "CarePlan",
+    Narrative = "Narrative",
+    MoneyQuantity = "MoneyQuantity",
+    TestReport = "TestReport",
+    Observation = "Observation",
+    DateTime = "dateTime",
+    Boolean = "boolean",
+    DocumentManifest = "DocumentManifest",
+    Contributor = "Contributor"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ParameterDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/ParameterDefinition.js
index c8ad2e5..1f9b965 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ParameterDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ParameterDefinition.js
@@ -1,2 +1,226 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterDefinitionType = exports.ParameterDefinitionUse = void 0;
+/** in | out */
+var ParameterDefinitionUse;
+(function (ParameterDefinitionUse) {
+    ParameterDefinitionUse["In"] = "in";
+    ParameterDefinitionUse["Out"] = "out";
+})(ParameterDefinitionUse = exports.ParameterDefinitionUse || (exports.ParameterDefinitionUse = {}));
+/** What type of value */
+var ParameterDefinitionType;
+(function (ParameterDefinitionType) {
+    ParameterDefinitionType["ImmunizationEvaluation"] = "ImmunizationEvaluation";
+    ParameterDefinitionType["Appointment"] = "Appointment";
+    ParameterDefinitionType["StructureMap"] = "StructureMap";
+    ParameterDefinitionType["Address"] = "Address";
+    ParameterDefinitionType["CareTeam"] = "CareTeam";
+    ParameterDefinitionType["UsageContext"] = "UsageContext";
+    ParameterDefinitionType["Linkage"] = "Linkage";
+    ParameterDefinitionType["Annotation"] = "Annotation";
+    ParameterDefinitionType["Age"] = "Age";
+    ParameterDefinitionType["Attachment"] = "Attachment";
+    ParameterDefinitionType["Communication"] = "Communication";
+    ParameterDefinitionType["MedicationDispense"] = "MedicationDispense";
+    ParameterDefinitionType["ImagingStudy"] = "ImagingStudy";
+    ParameterDefinitionType["ChargeItem"] = "ChargeItem";
+    ParameterDefinitionType["Period"] = "Period";
+    ParameterDefinitionType["AdverseEvent"] = "AdverseEvent";
+    ParameterDefinitionType["ContactDetail"] = "ContactDetail";
+    ParameterDefinitionType["DataRequirement"] = "DataRequirement";
+    ParameterDefinitionType["Media"] = "Media";
+    ParameterDefinitionType["CodeableConcept"] = "CodeableConcept";
+    ParameterDefinitionType["Uri"] = "uri";
+    ParameterDefinitionType["SubstancePolymer"] = "SubstancePolymer";
+    ParameterDefinitionType["QuestionnaireResponse"] = "QuestionnaireResponse";
+    ParameterDefinitionType["Coverage"] = "Coverage";
+    ParameterDefinitionType["Procedure"] = "Procedure";
+    ParameterDefinitionType["AuditEvent"] = "AuditEvent";
+    ParameterDefinitionType["PaymentReconciliation"] = "PaymentReconciliation";
+    ParameterDefinitionType["MedicinalProductManufactured"] = "MedicinalProductManufactured";
+    ParameterDefinitionType["CompartmentDefinition"] = "CompartmentDefinition";
+    ParameterDefinitionType["Type"] = "Type";
+    ParameterDefinitionType["Organization"] = "Organization";
+    ParameterDefinitionType["ExplanationOfBenefit"] = "ExplanationOfBenefit";
+    ParameterDefinitionType["Composition"] = "Composition";
+    ParameterDefinitionType["SimpleQuantity"] = "SimpleQuantity";
+    ParameterDefinitionType["CoverageEligibilityResponse"] = "CoverageEligibilityResponse";
+    ParameterDefinitionType["DocumentReference"] = "DocumentReference";
+    ParameterDefinitionType["EventDefinition"] = "EventDefinition";
+    ParameterDefinitionType["SubstanceProtein"] = "SubstanceProtein";
+    ParameterDefinitionType["TerminologyCapabilities"] = "TerminologyCapabilities";
+    ParameterDefinitionType["Encounter"] = "Encounter";
+    ParameterDefinitionType["ImplementationGuide"] = "ImplementationGuide";
+    ParameterDefinitionType["EvidenceVariable"] = "EvidenceVariable";
+    ParameterDefinitionType["ObservationDefinition"] = "ObservationDefinition";
+    ParameterDefinitionType["DiagnosticReport"] = "DiagnosticReport";
+    ParameterDefinitionType["ExampleScenario"] = "ExampleScenario";
+    ParameterDefinitionType["ResearchDefinition"] = "ResearchDefinition";
+    ParameterDefinitionType["Parameters"] = "Parameters";
+    ParameterDefinitionType["Instant"] = "instant";
+    ParameterDefinitionType["SearchParameter"] = "SearchParameter";
+    ParameterDefinitionType["MedicinalProductInteraction"] = "MedicinalProductInteraction";
+    ParameterDefinitionType["CodeSystem"] = "CodeSystem";
+    ParameterDefinitionType["MessageDefinition"] = "MessageDefinition";
+    ParameterDefinitionType["NutritionOrder"] = "NutritionOrder";
+    ParameterDefinitionType["VerificationResult"] = "VerificationResult";
+    ParameterDefinitionType["MedicationAdministration"] = "MedicationAdministration";
+    ParameterDefinitionType["CatalogEntry"] = "CatalogEntry";
+    ParameterDefinitionType["Flag"] = "Flag";
+    ParameterDefinitionType["DeviceUseStatement"] = "DeviceUseStatement";
+    ParameterDefinitionType["TriggerDefinition"] = "TriggerDefinition";
+    ParameterDefinitionType["Contract"] = "Contract";
+    ParameterDefinitionType["Invoice"] = "Invoice";
+    ParameterDefinitionType["MarketingStatus"] = "MarketingStatus";
+    ParameterDefinitionType["Count"] = "Count";
+    ParameterDefinitionType["PaymentNotice"] = "PaymentNotice";
+    ParameterDefinitionType["Location"] = "Location";
+    ParameterDefinitionType["Claim"] = "Claim";
+    ParameterDefinitionType["Specimen"] = "Specimen";
+    ParameterDefinitionType["MedicationStatement"] = "MedicationStatement";
+    ParameterDefinitionType["EnrollmentResponse"] = "EnrollmentResponse";
+    ParameterDefinitionType["Uuid"] = "uuid";
+    ParameterDefinitionType["Evidence"] = "Evidence";
+    ParameterDefinitionType["Bundle"] = "Bundle";
+    ParameterDefinitionType["ResearchElementDefinition"] = "ResearchElementDefinition";
+    ParameterDefinitionType["Expression"] = "Expression";
+    ParameterDefinitionType["Coding"] = "Coding";
+    ParameterDefinitionType["BodyStructure"] = "BodyStructure";
+    ParameterDefinitionType["MedicinalProduct"] = "MedicinalProduct";
+    ParameterDefinitionType["Canonical"] = "canonical";
+    ParameterDefinitionType["ResearchStudy"] = "ResearchStudy";
+    ParameterDefinitionType["Dosage"] = "Dosage";
+    ParameterDefinitionType["AppointmentResponse"] = "AppointmentResponse";
+    ParameterDefinitionType["MedicinalProductIndication"] = "MedicinalProductIndication";
+    ParameterDefinitionType["Measure"] = "Measure";
+    ParameterDefinitionType["Person"] = "Person";
+    ParameterDefinitionType["InsurancePlan"] = "InsurancePlan";
+    ParameterDefinitionType["Date"] = "date";
+    ParameterDefinitionType["Patient"] = "Patient";
+    ParameterDefinitionType["EffectEvidenceSynthesis"] = "EffectEvidenceSynthesis";
+    ParameterDefinitionType["ResearchSubject"] = "ResearchSubject";
+    ParameterDefinitionType["Medication"] = "Medication";
+    ParameterDefinitionType["Range"] = "Range";
+    ParameterDefinitionType["ConceptMap"] = "ConceptMap";
+    ParameterDefinitionType["CoverageEligibilityRequest"] = "CoverageEligibilityRequest";
+    ParameterDefinitionType["Population"] = "Population";
+    ParameterDefinitionType["SubstanceSourceMaterial"] = "SubstanceSourceMaterial";
+    ParameterDefinitionType["VisionPrescription"] = "VisionPrescription";
+    ParameterDefinitionType["MolecularSequence"] = "MolecularSequence";
+    ParameterDefinitionType["MedicinalProductUndesirableEffect"] = "MedicinalProductUndesirableEffect";
+    ParameterDefinitionType["OperationOutcome"] = "OperationOutcome";
+    ParameterDefinitionType["MessageHeader"] = "MessageHeader";
+    ParameterDefinitionType["ContactPoint"] = "ContactPoint";
+    ParameterDefinitionType["Signature"] = "Signature";
+    ParameterDefinitionType["Decimal"] = "decimal";
+    ParameterDefinitionType["Any"] = "Any";
+    ParameterDefinitionType["AllergyIntolerance"] = "AllergyIntolerance";
+    ParameterDefinitionType["SubstanceReferenceInformation"] = "SubstanceReferenceInformation";
+    ParameterDefinitionType["SupplyDelivery"] = "SupplyDelivery";
+    ParameterDefinitionType["EpisodeOfCare"] = "EpisodeOfCare";
+    ParameterDefinitionType["PractitionerRole"] = "PractitionerRole";
+    ParameterDefinitionType["Library"] = "Library";
+    ParameterDefinitionType["Practitioner"] = "Practitioner";
+    ParameterDefinitionType["Markdown"] = "markdown";
+    ParameterDefinitionType["MedicationRequest"] = "MedicationRequest";
+    ParameterDefinitionType["ImmunizationRecommendation"] = "ImmunizationRecommendation";
+    ParameterDefinitionType["RelatedArtifact"] = "RelatedArtifact";
+    ParameterDefinitionType["Timing"] = "Timing";
+    ParameterDefinitionType["Immunization"] = "Immunization";
+    ParameterDefinitionType["GraphDefinition"] = "GraphDefinition";
+    ParameterDefinitionType["Account"] = "Account";
+    ParameterDefinitionType["Url"] = "url";
+    ParameterDefinitionType["MedicinalProductIngredient"] = "MedicinalProductIngredient";
+    ParameterDefinitionType["ProdCharacteristic"] = "ProdCharacteristic";
+    ParameterDefinitionType["Meta"] = "Meta";
+    ParameterDefinitionType["Quantity"] = "Quantity";
+    ParameterDefinitionType["MeasureReport"] = "MeasureReport";
+    ParameterDefinitionType["Distance"] = "Distance";
+    ParameterDefinitionType["HumanName"] = "HumanName";
+    ParameterDefinitionType["DeviceMetric"] = "DeviceMetric";
+    ParameterDefinitionType["Duration"] = "Duration";
+    ParameterDefinitionType["SubstanceAmount"] = "SubstanceAmount";
+    ParameterDefinitionType["Goal"] = "Goal";
+    ParameterDefinitionType["MedicationKnowledge"] = "MedicationKnowledge";
+    ParameterDefinitionType["Integer"] = "integer";
+    ParameterDefinitionType["String"] = "string";
+    ParameterDefinitionType["ClaimResponse"] = "ClaimResponse";
+    ParameterDefinitionType["DeviceDefinition"] = "DeviceDefinition";
+    ParameterDefinitionType["Slot"] = "Slot";
+    ParameterDefinitionType["ValueSet"] = "ValueSet";
+    ParameterDefinitionType["MedicinalProductAuthorization"] = "MedicinalProductAuthorization";
+    ParameterDefinitionType["StructureDefinition"] = "StructureDefinition";
+    ParameterDefinitionType["Base64Binary"] = "base64Binary";
+    ParameterDefinitionType["MedicinalProductContraindication"] = "MedicinalProductContraindication";
+    ParameterDefinitionType["ElementDefinition"] = "ElementDefinition";
+    ParameterDefinitionType["DeviceRequest"] = "DeviceRequest";
+    ParameterDefinitionType["List"] = "List";
+    ParameterDefinitionType["Questionnaire"] = "Questionnaire";
+    ParameterDefinitionType["DomainResource"] = "DomainResource";
+    ParameterDefinitionType["Endpoint"] = "Endpoint";
+    ParameterDefinitionType["NamingSystem"] = "NamingSystem";
+    ParameterDefinitionType["MedicinalProductPackaged"] = "MedicinalProductPackaged";
+    ParameterDefinitionType["Basic"] = "Basic";
+    ParameterDefinitionType["Money"] = "Money";
+    ParameterDefinitionType["Binary"] = "Binary";
+    ParameterDefinitionType["PlanDefinition"] = "PlanDefinition";
+    ParameterDefinitionType["Subscription"] = "Subscription";
+    ParameterDefinitionType["SampledData"] = "SampledData";
+    ParameterDefinitionType["ProductShelfLife"] = "ProductShelfLife";
+    ParameterDefinitionType["RelatedPerson"] = "RelatedPerson";
+    ParameterDefinitionType["SubstanceSpecification"] = "SubstanceSpecification";
+    ParameterDefinitionType["Ratio"] = "Ratio";
+    ParameterDefinitionType["SubstanceNucleicAcid"] = "SubstanceNucleicAcid";
+    ParameterDefinitionType["GuidanceResponse"] = "GuidanceResponse";
+    ParameterDefinitionType["ClinicalImpression"] = "ClinicalImpression";
+    ParameterDefinitionType["OrganizationAffiliation"] = "OrganizationAffiliation";
+    ParameterDefinitionType["Resource"] = "Resource";
+    ParameterDefinitionType["UnsignedInt"] = "unsignedInt";
+    ParameterDefinitionType["Condition"] = "Condition";
+    ParameterDefinitionType["Extension"] = "Extension";
+    ParameterDefinitionType["CapabilityStatement"] = "CapabilityStatement";
+    ParameterDefinitionType["HealthcareService"] = "HealthcareService";
+    ParameterDefinitionType["SpecimenDefinition"] = "SpecimenDefinition";
+    ParameterDefinitionType["ParameterDefinition"] = "ParameterDefinition";
+    ParameterDefinitionType["RiskAssessment"] = "RiskAssessment";
+    ParameterDefinitionType["Xhtml"] = "xhtml";
+    ParameterDefinitionType["OperationDefinition"] = "OperationDefinition";
+    ParameterDefinitionType["ActivityDefinition"] = "ActivityDefinition";
+    ParameterDefinitionType["Schedule"] = "Schedule";
+    ParameterDefinitionType["BiologicallyDerivedProduct"] = "BiologicallyDerivedProduct";
+    ParameterDefinitionType["PositiveInt"] = "positiveInt";
+    ParameterDefinitionType["Code"] = "code";
+    ParameterDefinitionType["Group"] = "Group";
+    ParameterDefinitionType["MedicinalProductPharmaceutical"] = "MedicinalProductPharmaceutical";
+    ParameterDefinitionType["FamilyMemberHistory"] = "FamilyMemberHistory";
+    ParameterDefinitionType["ServiceRequest"] = "ServiceRequest";
+    ParameterDefinitionType["DetectedIssue"] = "DetectedIssue";
+    ParameterDefinitionType["Device"] = "Device";
+    ParameterDefinitionType["Oid"] = "oid";
+    ParameterDefinitionType["RequestGroup"] = "RequestGroup";
+    ParameterDefinitionType["TestScript"] = "TestScript";
+    ParameterDefinitionType["RiskEvidenceSynthesis"] = "RiskEvidenceSynthesis";
+    ParameterDefinitionType["SupplyRequest"] = "SupplyRequest";
+    ParameterDefinitionType["Element"] = "Element";
+    ParameterDefinitionType["Reference"] = "Reference";
+    ParameterDefinitionType["Task"] = "Task";
+    ParameterDefinitionType["Identifier"] = "Identifier";
+    ParameterDefinitionType["CommunicationRequest"] = "CommunicationRequest";
+    ParameterDefinitionType["EnrollmentRequest"] = "EnrollmentRequest";
+    ParameterDefinitionType["ChargeItemDefinition"] = "ChargeItemDefinition";
+    ParameterDefinitionType["Substance"] = "Substance";
+    ParameterDefinitionType["Id"] = "id";
+    ParameterDefinitionType["Provenance"] = "Provenance";
+    ParameterDefinitionType["Time"] = "time";
+    ParameterDefinitionType["Consent"] = "Consent";
+    ParameterDefinitionType["BackboneElement"] = "BackboneElement";
+    ParameterDefinitionType["CarePlan"] = "CarePlan";
+    ParameterDefinitionType["Narrative"] = "Narrative";
+    ParameterDefinitionType["MoneyQuantity"] = "MoneyQuantity";
+    ParameterDefinitionType["TestReport"] = "TestReport";
+    ParameterDefinitionType["Observation"] = "Observation";
+    ParameterDefinitionType["DateTime"] = "dateTime";
+    ParameterDefinitionType["Boolean"] = "boolean";
+    ParameterDefinitionType["DocumentManifest"] = "DocumentManifest";
+    ParameterDefinitionType["Contributor"] = "Contributor";
+})(ParameterDefinitionType = exports.ParameterDefinitionType || (exports.ParameterDefinitionType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Parameters.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Parameters.d.ts
index fb870ba..ef08b75 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Parameters.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Parameters.d.ts
@@ -53,6 +53,7 @@ import { decimal } from "./decimal";
 import { Contributor } from "./Contributor";
 /** This resource is a non-persisted resource used to pass information into and back from an [operation](operations.html). It has no other use, and there is no RESTful endpoint associated with it. */
 export interface Parameters extends Resource {
+    resourceType: 'Parameters';
     parameter?: Array<ParametersParameter>;
 }
 /** Operation Parameter */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Patient.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Patient.d.ts
index 76c6d23..c20e6e2 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Patient.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Patient.d.ts
@@ -12,11 +12,11 @@ import { DomainResource } from "./DomainResource";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Demographics and other administrative information about an individual or animal receiving care or other health-related services. */
 export interface Patient extends DomainResource {
+    resourceType: 'Patient';
     multipleBirthBoolean?: boolean;
     _active?: Element;
     /** An address for the individual */
@@ -24,7 +24,7 @@ export interface Patient extends DomainResource {
     deceasedDateTime?: dateTime;
     _deceasedDateTime?: Element;
     /** Organization that is the custodian of the patient record */
-    managingOrganization?: Reference<"Organization">;
+    managingOrganization?: Reference<'Organization'>;
     deceasedBoolean?: boolean;
     /** A name associated with the patient */
     name?: Array<HumanName>;
@@ -50,19 +50,26 @@ export interface Patient extends DomainResource {
     /** Patient's nominated primary care provider */
     generalPractitioner?: Array<Reference>;
     /** male | female | other | unknown */
-    gender?: code;
+    gender?: `${PatientGender}`;
     /** Marital (civil) status of a patient */
     maritalStatus?: CodeableConcept;
     /** A contact party (e.g. guardian, partner, friend) for the patient */
     contact?: Array<PatientContact>;
     _multipleBirthBoolean?: Element;
 }
+/** replaced-by | replaces | refer | seealso */
+export declare enum PatientType {
+    Refer = "refer",
+    ReplacedBy = "replaced-by",
+    Replaces = "replaces",
+    Seealso = "seealso"
+}
 /** Link to another patient resource that concerns the same actual person */
 export interface PatientLink extends BackboneElement {
     /** The other patient or related person resource that the link refers to */
-    other: Reference<"Patient" | "RelatedPerson">;
+    other: Reference<'Patient' | 'RelatedPerson'>;
     /** replaced-by | replaces | refer | seealso */
-    type: code;
+    type: `${PatientType}`;
     _type?: Element;
 }
 /** A language which may be used to communicate with the patient about his or her health */
@@ -73,6 +80,13 @@ export interface PatientCommunication extends BackboneElement {
     preferred?: boolean;
     _preferred?: Element;
 }
+/** male | female | other | unknown */
+export declare enum PatientGender {
+    Female = "female",
+    Male = "male",
+    Other = "other",
+    Unknown = "unknown"
+}
 /** A contact party (e.g. guardian, partner, friend) for the patient */
 export interface PatientContact extends BackboneElement {
     /** The kind of relationship */
@@ -84,10 +98,10 @@ export interface PatientContact extends BackboneElement {
     /** Address for the contact person */
     address?: Address;
     /** male | female | other | unknown */
-    gender?: code;
+    gender?: `${PatientGender}`;
     _gender?: Element;
     /** Organization that is associated with the contact */
-    organization?: Reference<"Organization">;
+    organization?: Reference<'Organization'>;
     /** The period during which this contact person or organization is valid to be contacted relating to this patient */
     period?: Period;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Patient.js b/vendor/r4/types/hl7-fhir-r4-core/Patient.js
index c8ad2e5..43bdc05 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Patient.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Patient.js
@@ -1,2 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatientGender = exports.PatientType = void 0;
+/** replaced-by | replaces | refer | seealso */
+var PatientType;
+(function (PatientType) {
+    PatientType["Refer"] = "refer";
+    PatientType["ReplacedBy"] = "replaced-by";
+    PatientType["Replaces"] = "replaces";
+    PatientType["Seealso"] = "seealso";
+})(PatientType = exports.PatientType || (exports.PatientType = {}));
+/** male | female | other | unknown */
+var PatientGender;
+(function (PatientGender) {
+    PatientGender["Female"] = "female";
+    PatientGender["Male"] = "male";
+    PatientGender["Other"] = "other";
+    PatientGender["Unknown"] = "unknown";
+})(PatientGender = exports.PatientGender || (exports.PatientGender = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/PaymentNotice.d.ts b/vendor/r4/types/hl7-fhir-r4-core/PaymentNotice.d.ts
index f1b5851..8a8d284 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/PaymentNotice.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/PaymentNotice.d.ts
@@ -7,10 +7,10 @@ import { Money } from "./Money";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** This resource provides the status of the payment for goods and services rendered, and the request and response resource references. */
 export interface PaymentNotice extends DomainResource {
+    resourceType: 'PaymentNotice';
     /** Response reference */
     response?: Reference;
     _created?: Element;
@@ -19,23 +19,30 @@ export interface PaymentNotice extends DomainResource {
     /** Request reference */
     request?: Reference;
     /** Payment reference */
-    payment: Reference<"PaymentReconciliation">;
+    payment: Reference<'PaymentReconciliation'>;
     _status?: Element;
     /** Party being notified */
-    recipient: Reference<"Organization">;
+    recipient: Reference<'Organization'>;
     /** Creation date */
     created: dateTime;
     /** Issued or cleared Status of the payment */
     paymentStatus?: CodeableConcept;
     /** active | cancelled | draft | entered-in-error */
-    status: code;
+    status: `${PaymentNoticeStatus}`;
     /** Party being paid */
-    payee?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    payee?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Payment or clearing date */
     paymentDate?: date;
     /** Business Identifier for the payment noctice */
     identifier?: Array<Identifier>;
     _paymentDate?: Element;
     /** Responsible practitioner */
-    provider?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    provider?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
+}
+/** active | cancelled | draft | entered-in-error */
+export declare enum PaymentNoticeStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    EnteredInError = "entered-in-error"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/PaymentNotice.js b/vendor/r4/types/hl7-fhir-r4-core/PaymentNotice.js
index c8ad2e5..bbdf810 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/PaymentNotice.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/PaymentNotice.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentNoticeStatus = void 0;
+/** active | cancelled | draft | entered-in-error */
+var PaymentNoticeStatus;
+(function (PaymentNoticeStatus) {
+    PaymentNoticeStatus["Active"] = "active";
+    PaymentNoticeStatus["Cancelled"] = "cancelled";
+    PaymentNoticeStatus["Draft"] = "draft";
+    PaymentNoticeStatus["EnteredInError"] = "entered-in-error";
+})(PaymentNoticeStatus = exports.PaymentNoticeStatus || (exports.PaymentNoticeStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/PaymentReconciliation.d.ts b/vendor/r4/types/hl7-fhir-r4-core/PaymentReconciliation.d.ts
index d3713c1..04a93da 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/PaymentReconciliation.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/PaymentReconciliation.d.ts
@@ -8,16 +8,16 @@ import { Money } from "./Money";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** This resource provides the details including amount of a payment and allocates the payment items being paid. */
 export interface PaymentReconciliation extends DomainResource {
+    resourceType: 'PaymentReconciliation';
     _created?: Element;
     /** Responsible practitioner */
-    requestor?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    requestor?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Reference to requesting resource */
-    request?: Reference<"Task">;
+    request?: Reference<'Task'>;
     /** Total amount of Payment */
     paymentAmount: Money;
     /** Note concerning processing */
@@ -27,14 +27,14 @@ export interface PaymentReconciliation extends DomainResource {
     /** Creation date */
     created: dateTime;
     /** queued | complete | error | partial */
-    outcome?: code;
+    outcome?: `${PaymentReconciliationOutcome}`;
     _outcome?: Element;
     /** Disposition message */
     disposition?: string;
     /** Business identifier for the payment */
     paymentIdentifier?: Identifier;
     /** active | cancelled | draft | entered-in-error */
-    status: code;
+    status: `${PaymentReconciliationStatus}`;
     /** When payment issued */
     paymentDate: date;
     /** Business Identifier for a payment reconciliation */
@@ -43,21 +43,41 @@ export interface PaymentReconciliation extends DomainResource {
     /** Period covered */
     period?: Period;
     /** Party generating payment */
-    paymentIssuer?: Reference<"Organization">;
+    paymentIssuer?: Reference<'Organization'>;
     /** Printed form identifier */
     formCode?: CodeableConcept;
     /** Settlement particulars */
     detail?: Array<PaymentReconciliationDetail>;
 }
+/** display | print | printoper */
+export declare enum PaymentReconciliationType {
+    Display = "display",
+    Print = "print",
+    Printoper = "printoper"
+}
 /** Note concerning processing */
 export interface PaymentReconciliationProcessNote extends BackboneElement {
     /** display | print | printoper */
-    type?: code;
+    type?: `${PaymentReconciliationType}`;
     _type?: Element;
     /** Note explanatory text */
     text?: string;
     _text?: Element;
 }
+/** queued | complete | error | partial */
+export declare enum PaymentReconciliationOutcome {
+    Complete = "complete",
+    Error = "error",
+    Partial = "partial",
+    Queued = "queued"
+}
+/** active | cancelled | draft | entered-in-error */
+export declare enum PaymentReconciliationStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    EnteredInError = "entered-in-error"
+}
 /** Settlement particulars */
 export interface PaymentReconciliationDetail extends BackboneElement {
     /** Response committing to a payment */
@@ -72,13 +92,13 @@ export interface PaymentReconciliationDetail extends BackboneElement {
     /** Category of payment */
     type: CodeableConcept;
     /** Contact for the response */
-    responsible?: Reference<"PractitionerRole">;
+    responsible?: Reference<'PractitionerRole'>;
     /** Recipient of the payment */
-    payee?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    payee?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Business identifier of the prior payment detail */
     predecessor?: Identifier;
     /** Business identifier of the payment detail */
     identifier?: Identifier;
     /** Submitter of the request */
-    submitter?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    submitter?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/PaymentReconciliation.js b/vendor/r4/types/hl7-fhir-r4-core/PaymentReconciliation.js
index c8ad2e5..506f78b 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/PaymentReconciliation.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/PaymentReconciliation.js
@@ -1,2 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentReconciliationStatus = exports.PaymentReconciliationOutcome = exports.PaymentReconciliationType = void 0;
+/** display | print | printoper */
+var PaymentReconciliationType;
+(function (PaymentReconciliationType) {
+    PaymentReconciliationType["Display"] = "display";
+    PaymentReconciliationType["Print"] = "print";
+    PaymentReconciliationType["Printoper"] = "printoper";
+})(PaymentReconciliationType = exports.PaymentReconciliationType || (exports.PaymentReconciliationType = {}));
+/** queued | complete | error | partial */
+var PaymentReconciliationOutcome;
+(function (PaymentReconciliationOutcome) {
+    PaymentReconciliationOutcome["Complete"] = "complete";
+    PaymentReconciliationOutcome["Error"] = "error";
+    PaymentReconciliationOutcome["Partial"] = "partial";
+    PaymentReconciliationOutcome["Queued"] = "queued";
+})(PaymentReconciliationOutcome = exports.PaymentReconciliationOutcome || (exports.PaymentReconciliationOutcome = {}));
+/** active | cancelled | draft | entered-in-error */
+var PaymentReconciliationStatus;
+(function (PaymentReconciliationStatus) {
+    PaymentReconciliationStatus["Active"] = "active";
+    PaymentReconciliationStatus["Cancelled"] = "cancelled";
+    PaymentReconciliationStatus["Draft"] = "draft";
+    PaymentReconciliationStatus["EnteredInError"] = "entered-in-error";
+})(PaymentReconciliationStatus = exports.PaymentReconciliationStatus || (exports.PaymentReconciliationStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Person.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Person.d.ts
index bd0baa8..821d6ae 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Person.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Person.d.ts
@@ -8,16 +8,16 @@ import { DomainResource } from "./DomainResource";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Demographics and administrative information about a person independent of a specific health-related context. */
 export interface Person extends DomainResource {
+    resourceType: 'Person';
     _active?: Element;
     /** One or more addresses for the person */
     address?: Array<Address>;
     /** The organization that is the custodian of the person record */
-    managingOrganization?: Reference<"Organization">;
+    managingOrganization?: Reference<'Organization'>;
     /** A name associated with the person */
     name?: Array<HumanName>;
     _gender?: Element;
@@ -35,13 +35,27 @@ export interface Person extends DomainResource {
     /** A contact detail for the person */
     telecom?: Array<ContactPoint>;
     /** male | female | other | unknown */
-    gender?: code;
+    gender?: `${PersonGender}`;
+}
+/** level1 | level2 | level3 | level4 */
+export declare enum PersonAssurance {
+    Level1 = "level1",
+    Level2 = "level2",
+    Level3 = "level3",
+    Level4 = "level4"
 }
 /** Link to a resource that concerns the same actual person */
 export interface PersonLink extends BackboneElement {
     /** The resource to which this actual person is associated */
-    target: Reference<"Patient" | "Person" | "Practitioner" | "RelatedPerson">;
+    target: Reference<'Patient' | 'Person' | 'Practitioner' | 'RelatedPerson'>;
     /** level1 | level2 | level3 | level4 */
-    assurance?: code;
+    assurance?: `${PersonAssurance}`;
     _assurance?: Element;
 }
+/** male | female | other | unknown */
+export declare enum PersonGender {
+    Female = "female",
+    Male = "male",
+    Other = "other",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Person.js b/vendor/r4/types/hl7-fhir-r4-core/Person.js
index c8ad2e5..8ccf8e5 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Person.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Person.js
@@ -1,2 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonGender = exports.PersonAssurance = void 0;
+/** level1 | level2 | level3 | level4 */
+var PersonAssurance;
+(function (PersonAssurance) {
+    PersonAssurance["Level1"] = "level1";
+    PersonAssurance["Level2"] = "level2";
+    PersonAssurance["Level3"] = "level3";
+    PersonAssurance["Level4"] = "level4";
+})(PersonAssurance = exports.PersonAssurance || (exports.PersonAssurance = {}));
+/** male | female | other | unknown */
+var PersonGender;
+(function (PersonGender) {
+    PersonGender["Female"] = "female";
+    PersonGender["Male"] = "male";
+    PersonGender["Other"] = "other";
+    PersonGender["Unknown"] = "unknown";
+})(PersonGender = exports.PersonGender || (exports.PersonGender = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/PlanDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/PlanDefinition.d.ts
index 7e10370..cfd817a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/PlanDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/PlanDefinition.d.ts
@@ -22,11 +22,11 @@ import { date } from "./date";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical artifacts such as clinical decision support rules, order sets and protocols. */
 export interface PlanDefinition extends DomainResource {
+    resourceType: 'PlanDefinition';
     /** Natural language description of the plan definition */
     description?: markdown;
     _usage?: Element;
@@ -74,7 +74,7 @@ export interface PlanDefinition extends DomainResource {
     usage?: string;
     _lastReviewDate?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${PlanDefinitionStatus}`;
     /** Subordinate title of the plan definition */
     subtitle?: string;
     _name?: Element;
@@ -100,20 +100,56 @@ export interface PlanDefinition extends DomainResource {
     relatedArtifact?: Array<RelatedArtifact>;
     /** Contact details for the publisher */
     contact?: Array<ContactDetail>;
-    subjectReference?: Reference<"Group">;
+    subjectReference?: Reference<'Group'>;
     _url?: Element;
     /** When the plan definition is expected to be used */
     effectivePeriod?: Period;
 }
-/** Target outcome for the goal */
-export interface PlanDefinitionTarget extends BackboneElement {
-    /** The parameter whose value is to be tracked */
-    measure?: CodeableConcept;
-    detailQuantity?: Quantity;
-    detailRange?: Range;
-    detailCodeableConcept?: CodeableConcept;
-    /** Reach goal within */
-    due?: Duration;
+/** Dynamic aspects of the definition */
+export interface PlanDefinitionActionDynamicValue extends BackboneElement {
+    /** The path to the element to be set dynamically */
+    path?: string;
+    _path?: Element;
+    /** An expression that provides the dynamic value for the customization */
+    expression?: Expression;
+}
+/** Who should participate in the action */
+export interface PlanDefinitionActionParticipant extends BackboneElement {
+    /** patient | practitioner | related-person | device */
+    type: `${PlanDefinitionActionType}`;
+    _type?: Element;
+    /** E.g. Nurse, Surgeon, Parent */
+    role?: CodeableConcept;
+}
+/** patient | practitioner | related-person | device */
+export declare enum PlanDefinitionActionType {
+    Device = "device",
+    Patient = "patient",
+    Practitioner = "practitioner",
+    RelatedPerson = "related-person"
+}
+/** Relationship to another action */
+export interface PlanDefinitionActionRelatedAction extends BackboneElement {
+    /** What action is this related to */
+    actionId: id;
+    _actionId?: Element;
+    /** before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end */
+    relationship: `${PlanDefinitionActionRelationship}`;
+    _relationship?: Element;
+    offsetDuration?: Duration;
+    offsetRange?: Range;
+}
+/** before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end */
+export declare enum PlanDefinitionActionRelationship {
+    BeforeStart = "before-start",
+    Concurrent = "concurrent",
+    After = "after",
+    ConcurrentWithStart = "concurrent-with-start",
+    BeforeEnd = "before-end",
+    AfterEnd = "after-end",
+    AfterStart = "after-start",
+    Before = "before",
+    ConcurrentWithEnd = "concurrent-with-end"
 }
 /** What the plan is trying to accomplish */
 export interface PlanDefinitionGoal extends BackboneElement {
@@ -132,40 +168,33 @@ export interface PlanDefinitionGoal extends BackboneElement {
     /** Target outcome for the goal */
     target?: Array<PlanDefinitionTarget>;
 }
-/** Relationship to another action */
-export interface PlanDefinitionActionRelatedAction extends BackboneElement {
-    /** What action is this related to */
-    actionId: id;
-    _actionId?: Element;
-    /** before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end */
-    relationship: code;
-    _relationship?: Element;
-    offsetDuration?: Duration;
-    offsetRange?: Range;
+/** visual-group | logical-group | sentence-group */
+export declare enum PlanDefinitionActionGroupingBehavior {
+    LogicalGroup = "logical-group",
+    SentenceGroup = "sentence-group",
+    VisualGroup = "visual-group"
 }
-/** Who should participate in the action */
-export interface PlanDefinitionActionParticipant extends BackboneElement {
-    /** patient | practitioner | related-person | device */
-    type: code;
-    _type?: Element;
-    /** E.g. Nurse, Surgeon, Parent */
-    role?: CodeableConcept;
+/** applicability | start | stop */
+export declare enum PlanDefinitionActionKind {
+    Applicability = "applicability",
+    Start = "start",
+    Stop = "stop"
 }
-/** Whether or not the action is applicable */
-export interface PlanDefinitionActionCondition extends BackboneElement {
-    /** applicability | start | stop */
-    kind: code;
-    _kind?: Element;
-    /** Boolean-valued expression */
-    expression?: Expression;
+/** draft | active | retired | unknown */
+export declare enum PlanDefinitionStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
 }
-/** Dynamic aspects of the definition */
-export interface PlanDefinitionActionDynamicValue extends BackboneElement {
-    /** The path to the element to be set dynamically */
-    path?: string;
-    _path?: Element;
-    /** An expression that provides the dynamic value for the customization */
-    expression?: Expression;
+/** any | all | all-or-none | exactly-one | at-most-one | one-or-more */
+export declare enum PlanDefinitionActionSelectionBehavior {
+    All = "all",
+    AllOrNone = "all-or-none",
+    Any = "any",
+    AtMostOne = "at-most-one",
+    ExactlyOne = "exactly-one",
+    OneOrMore = "one-or-more"
 }
 /** Action defined by the plan */
 export interface PlanDefinitionAction extends BackboneElement {
@@ -204,7 +233,7 @@ export interface PlanDefinitionAction extends BackboneElement {
     /** User-visible prefix for the action (e.g. 1. or A.) */
     prefix?: string;
     /** any | all | all-or-none | exactly-one | at-most-one | one-or-more */
-    selectionBehavior?: code;
+    selectionBehavior?: `${PlanDefinitionActionSelectionBehavior}`;
     _definitionCanonical?: Element;
     /** Why the action should be performed */
     reason?: Array<CodeableConcept>;
@@ -212,15 +241,15 @@ export interface PlanDefinitionAction extends BackboneElement {
     timingTiming?: Timing;
     timingDuration?: Duration;
     /** routine | urgent | asap | stat */
-    priority?: code;
+    priority?: `${PlanDefinitionActionPriority}`;
     _transform?: Element;
     /** must | could | must-unless-documented */
-    requiredBehavior?: code;
+    requiredBehavior?: `${PlanDefinitionActionRequiredBehavior}`;
     _goalId?: Array<Element>;
     /** Whether or not the action is applicable */
     condition?: Array<PlanDefinitionActionCondition>;
     /** visual-group | logical-group | sentence-group */
-    groupingBehavior?: code;
+    groupingBehavior?: `${PlanDefinitionActionGroupingBehavior}`;
     /** Dynamic aspects of the definition */
     dynamicValue?: Array<PlanDefinitionActionDynamicValue>;
     /** Code representing the meaning of the action or sub-actions */
@@ -231,15 +260,56 @@ export interface PlanDefinitionAction extends BackboneElement {
     action?: Array<PlanDefinitionAction>;
     _selectionBehavior?: Element;
     /** yes | no */
-    precheckBehavior?: code;
+    precheckBehavior?: `${PlanDefinitionActionPrecheckBehavior}`;
     _title?: Element;
     /** Input data requirements */
     input?: Array<DataRequirement>;
     _cardinalityBehavior?: Element;
     /** When the action should be triggered */
     trigger?: Array<TriggerDefinition>;
-    subjectReference?: Reference<"Group">;
+    subjectReference?: Reference<'Group'>;
     _textEquivalent?: Element;
     /** single | multiple */
-    cardinalityBehavior?: code;
+    cardinalityBehavior?: `${PlanDefinitionActionCardinalityBehavior}`;
+}
+/** Whether or not the action is applicable */
+export interface PlanDefinitionActionCondition extends BackboneElement {
+    /** applicability | start | stop */
+    kind: `${PlanDefinitionActionKind}`;
+    _kind?: Element;
+    /** Boolean-valued expression */
+    expression?: Expression;
+}
+/** yes | no */
+export declare enum PlanDefinitionActionPrecheckBehavior {
+    No = "no",
+    Yes = "yes"
+}
+/** single | multiple */
+export declare enum PlanDefinitionActionCardinalityBehavior {
+    Multiple = "multiple",
+    Single = "single"
+}
+/** Target outcome for the goal */
+export interface PlanDefinitionTarget extends BackboneElement {
+    /** The parameter whose value is to be tracked */
+    measure?: CodeableConcept;
+    detailQuantity?: Quantity;
+    detailRange?: Range;
+    detailCodeableConcept?: CodeableConcept;
+    /** Reach goal within */
+    due?: Duration;
+}
+/** routine | urgent | asap | stat */
+export declare enum PlanDefinitionActionPriority {
+    Asap = "asap",
+    Routine = "routine",
+    Stat = "stat",
+    Urgent = "urgent"
+}
+/** must | could | must-unless-documented */
+export declare enum PlanDefinitionActionRequiredBehavior {
+    Could = "could",
+    Must = "must",
+    MustUnlessDocumented = "must-unless-documented"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/PlanDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/PlanDefinition.js
index c8ad2e5..4a6cfd1 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/PlanDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/PlanDefinition.js
@@ -1,2 +1,83 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanDefinitionActionRequiredBehavior = exports.PlanDefinitionActionPriority = exports.PlanDefinitionActionCardinalityBehavior = exports.PlanDefinitionActionPrecheckBehavior = exports.PlanDefinitionActionSelectionBehavior = exports.PlanDefinitionStatus = exports.PlanDefinitionActionKind = exports.PlanDefinitionActionGroupingBehavior = exports.PlanDefinitionActionRelationship = exports.PlanDefinitionActionType = void 0;
+/** patient | practitioner | related-person | device */
+var PlanDefinitionActionType;
+(function (PlanDefinitionActionType) {
+    PlanDefinitionActionType["Device"] = "device";
+    PlanDefinitionActionType["Patient"] = "patient";
+    PlanDefinitionActionType["Practitioner"] = "practitioner";
+    PlanDefinitionActionType["RelatedPerson"] = "related-person";
+})(PlanDefinitionActionType = exports.PlanDefinitionActionType || (exports.PlanDefinitionActionType = {}));
+/** before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end */
+var PlanDefinitionActionRelationship;
+(function (PlanDefinitionActionRelationship) {
+    PlanDefinitionActionRelationship["BeforeStart"] = "before-start";
+    PlanDefinitionActionRelationship["Concurrent"] = "concurrent";
+    PlanDefinitionActionRelationship["After"] = "after";
+    PlanDefinitionActionRelationship["ConcurrentWithStart"] = "concurrent-with-start";
+    PlanDefinitionActionRelationship["BeforeEnd"] = "before-end";
+    PlanDefinitionActionRelationship["AfterEnd"] = "after-end";
+    PlanDefinitionActionRelationship["AfterStart"] = "after-start";
+    PlanDefinitionActionRelationship["Before"] = "before";
+    PlanDefinitionActionRelationship["ConcurrentWithEnd"] = "concurrent-with-end";
+})(PlanDefinitionActionRelationship = exports.PlanDefinitionActionRelationship || (exports.PlanDefinitionActionRelationship = {}));
+/** visual-group | logical-group | sentence-group */
+var PlanDefinitionActionGroupingBehavior;
+(function (PlanDefinitionActionGroupingBehavior) {
+    PlanDefinitionActionGroupingBehavior["LogicalGroup"] = "logical-group";
+    PlanDefinitionActionGroupingBehavior["SentenceGroup"] = "sentence-group";
+    PlanDefinitionActionGroupingBehavior["VisualGroup"] = "visual-group";
+})(PlanDefinitionActionGroupingBehavior = exports.PlanDefinitionActionGroupingBehavior || (exports.PlanDefinitionActionGroupingBehavior = {}));
+/** applicability | start | stop */
+var PlanDefinitionActionKind;
+(function (PlanDefinitionActionKind) {
+    PlanDefinitionActionKind["Applicability"] = "applicability";
+    PlanDefinitionActionKind["Start"] = "start";
+    PlanDefinitionActionKind["Stop"] = "stop";
+})(PlanDefinitionActionKind = exports.PlanDefinitionActionKind || (exports.PlanDefinitionActionKind = {}));
+/** draft | active | retired | unknown */
+var PlanDefinitionStatus;
+(function (PlanDefinitionStatus) {
+    PlanDefinitionStatus["Active"] = "active";
+    PlanDefinitionStatus["Draft"] = "draft";
+    PlanDefinitionStatus["Retired"] = "retired";
+    PlanDefinitionStatus["Unknown"] = "unknown";
+})(PlanDefinitionStatus = exports.PlanDefinitionStatus || (exports.PlanDefinitionStatus = {}));
+/** any | all | all-or-none | exactly-one | at-most-one | one-or-more */
+var PlanDefinitionActionSelectionBehavior;
+(function (PlanDefinitionActionSelectionBehavior) {
+    PlanDefinitionActionSelectionBehavior["All"] = "all";
+    PlanDefinitionActionSelectionBehavior["AllOrNone"] = "all-or-none";
+    PlanDefinitionActionSelectionBehavior["Any"] = "any";
+    PlanDefinitionActionSelectionBehavior["AtMostOne"] = "at-most-one";
+    PlanDefinitionActionSelectionBehavior["ExactlyOne"] = "exactly-one";
+    PlanDefinitionActionSelectionBehavior["OneOrMore"] = "one-or-more";
+})(PlanDefinitionActionSelectionBehavior = exports.PlanDefinitionActionSelectionBehavior || (exports.PlanDefinitionActionSelectionBehavior = {}));
+/** yes | no */
+var PlanDefinitionActionPrecheckBehavior;
+(function (PlanDefinitionActionPrecheckBehavior) {
+    PlanDefinitionActionPrecheckBehavior["No"] = "no";
+    PlanDefinitionActionPrecheckBehavior["Yes"] = "yes";
+})(PlanDefinitionActionPrecheckBehavior = exports.PlanDefinitionActionPrecheckBehavior || (exports.PlanDefinitionActionPrecheckBehavior = {}));
+/** single | multiple */
+var PlanDefinitionActionCardinalityBehavior;
+(function (PlanDefinitionActionCardinalityBehavior) {
+    PlanDefinitionActionCardinalityBehavior["Multiple"] = "multiple";
+    PlanDefinitionActionCardinalityBehavior["Single"] = "single";
+})(PlanDefinitionActionCardinalityBehavior = exports.PlanDefinitionActionCardinalityBehavior || (exports.PlanDefinitionActionCardinalityBehavior = {}));
+/** routine | urgent | asap | stat */
+var PlanDefinitionActionPriority;
+(function (PlanDefinitionActionPriority) {
+    PlanDefinitionActionPriority["Asap"] = "asap";
+    PlanDefinitionActionPriority["Routine"] = "routine";
+    PlanDefinitionActionPriority["Stat"] = "stat";
+    PlanDefinitionActionPriority["Urgent"] = "urgent";
+})(PlanDefinitionActionPriority = exports.PlanDefinitionActionPriority || (exports.PlanDefinitionActionPriority = {}));
+/** must | could | must-unless-documented */
+var PlanDefinitionActionRequiredBehavior;
+(function (PlanDefinitionActionRequiredBehavior) {
+    PlanDefinitionActionRequiredBehavior["Could"] = "could";
+    PlanDefinitionActionRequiredBehavior["Must"] = "must";
+    PlanDefinitionActionRequiredBehavior["MustUnlessDocumented"] = "must-unless-documented";
+})(PlanDefinitionActionRequiredBehavior = exports.PlanDefinitionActionRequiredBehavior || (exports.PlanDefinitionActionRequiredBehavior = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Practitioner.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Practitioner.d.ts
index 0184dcc..fd60bdd 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Practitioner.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Practitioner.d.ts
@@ -10,11 +10,11 @@ import { DomainResource } from "./DomainResource";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A person who is directly or indirectly involved in the provisioning of healthcare. */
 export interface Practitioner extends DomainResource {
+    resourceType: 'Practitioner';
     _active?: Element;
     /** Address(es) of the practitioner that are not role specific (typically home address) */
     address?: Array<Address>;
@@ -37,7 +37,7 @@ export interface Practitioner extends DomainResource {
     /** A contact detail for the practitioner (that apply to all roles) */
     telecom?: Array<ContactPoint>;
     /** male | female | other | unknown */
-    gender?: code;
+    gender?: `${PractitionerGender}`;
 }
 /** Certification, licenses, or training pertaining to the provision of care */
 export interface PractitionerQualification extends BackboneElement {
@@ -48,5 +48,12 @@ export interface PractitionerQualification extends BackboneElement {
     /** Period during which the qualification is valid */
     period?: Period;
     /** Organization that regulates and issues the qualification */
-    issuer?: Reference<"Organization">;
+    issuer?: Reference<'Organization'>;
+}
+/** male | female | other | unknown */
+export declare enum PractitionerGender {
+    Female = "female",
+    Male = "male",
+    Other = "other",
+    Unknown = "unknown"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Practitioner.js b/vendor/r4/types/hl7-fhir-r4-core/Practitioner.js
index c8ad2e5..bb35d81 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Practitioner.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Practitioner.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PractitionerGender = void 0;
+/** male | female | other | unknown */
+var PractitionerGender;
+(function (PractitionerGender) {
+    PractitionerGender["Female"] = "female";
+    PractitionerGender["Male"] = "male";
+    PractitionerGender["Other"] = "other";
+    PractitionerGender["Unknown"] = "unknown";
+})(PractitionerGender = exports.PractitionerGender || (exports.PractitionerGender = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/PractitionerRole.d.ts b/vendor/r4/types/hl7-fhir-r4-core/PractitionerRole.d.ts
index b8ba7d2..c3ce6a4 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/PractitionerRole.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/PractitionerRole.d.ts
@@ -12,6 +12,7 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time. */
 export interface PractitionerRole extends DomainResource {
+    resourceType: 'PractitionerRole';
     _active?: Element;
     /** Times the Service Site is available */
     availableTime?: Array<PractitionerRoleAvailableTime>;
@@ -20,7 +21,7 @@ export interface PractitionerRole extends DomainResource {
     /** Not available during this time due to provided reason */
     notAvailable?: Array<PractitionerRoleNotAvailable>;
     /** Organization where the roles are available */
-    organization?: Reference<"Organization">;
+    organization?: Reference<'Organization'>;
     /** Whether this practitioner role record is in active use */
     active?: boolean;
     _availabilityExceptions?: Element;
@@ -31,7 +32,7 @@ export interface PractitionerRole extends DomainResource {
     /** Description of availability exceptions */
     availabilityExceptions?: string;
     /** Practitioner that is able to provide the defined services for the organization */
-    practitioner?: Reference<"Practitioner">;
+    practitioner?: Reference<'Practitioner'>;
     /** Contact details that are specific to the role/location/service */
     telecom?: Array<ContactPoint>;
     /** The period during which the practitioner is authorized to perform in these role(s) */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Procedure.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Procedure.d.ts
index e5b8fec..8019e49 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Procedure.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Procedure.d.ts
@@ -11,11 +11,11 @@ import { canonical } from "./canonical";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** An action that is or was performed on or for a patient. This can be a physical intervention like an operation, or less invasive like long term services, counseling, or hypnotherapy. */
 export interface Procedure extends DomainResource {
+    resourceType: 'Procedure';
     /** Classification of the procedure */
     category?: CodeableConcept;
     /** Any report resulting from the procedure */
@@ -32,7 +32,7 @@ export interface Procedure extends DomainResource {
     /** Manipulated, implanted, or removed device */
     focalDevice?: Array<ProcedureFocalDevice>;
     /** Encounter created as part of */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     performedAge?: Age;
     /** A condition that is a result of the procedure */
     complicationDetail?: Array<Reference>;
@@ -46,17 +46,17 @@ export interface Procedure extends DomainResource {
     /** The result of procedure */
     outcome?: CodeableConcept;
     /** Person who asserts this procedure */
-    asserter?: Reference<"Patient" | "PractitionerRole" | "Practitioner" | "RelatedPerson">;
+    asserter?: Reference<'Patient' | 'PractitionerRole' | 'Practitioner' | 'RelatedPerson'>;
     /** Additional information about the procedure */
     note?: Array<Annotation>;
     performedRange?: Range;
     /** Complication following the procedure */
     complication?: Array<CodeableConcept>;
     /** preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown */
-    status: code;
+    status: `${ProcedureStatus}`;
     performedDateTime?: dateTime;
     /** Who recorded the procedure */
-    recorder?: Reference<"Patient" | "PractitionerRole" | "Practitioner" | "RelatedPerson">;
+    recorder?: Reference<'Patient' | 'PractitionerRole' | 'Practitioner' | 'RelatedPerson'>;
     /** Identification of the procedure */
     code?: CodeableConcept;
     /** External Identifiers for this procedure */
@@ -69,12 +69,12 @@ export interface Procedure extends DomainResource {
     partOf?: Array<Reference>;
     performedPeriod?: Period;
     /** Where the procedure happened */
-    location?: Reference<"Location">;
+    location?: Reference<'Location'>;
     /** Instructions for follow up */
     followUp?: Array<CodeableConcept>;
     _instantiatesCanonical?: Array<Element>;
     /** Who the procedure was performed on */
-    subject: Reference<"Patient" | "Group">;
+    subject: Reference<'Patient' | 'Group'>;
     /** The people who performed the procedure */
     performer?: Array<ProcedurePerformer>;
     /** The justification that the procedure was performed */
@@ -86,14 +86,25 @@ export interface ProcedureFocalDevice extends BackboneElement {
     /** Kind of change to device */
     action?: CodeableConcept;
     /** Device that was changed */
-    manipulated: Reference<"Device">;
+    manipulated: Reference<'Device'>;
+}
+/** preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown */
+export declare enum ProcedureStatus {
+    Completed = "completed",
+    EnteredInError = "entered-in-error",
+    InProgress = "in-progress",
+    NotDone = "not-done",
+    OnHold = "on-hold",
+    Preparation = "preparation",
+    Stopped = "stopped",
+    Unknown = "unknown"
 }
 /** The people who performed the procedure */
 export interface ProcedurePerformer extends BackboneElement {
     /** Type of performance */
     function?: CodeableConcept;
     /** The reference to the practitioner */
-    actor: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    actor: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** Organization the device or practitioner was acting for */
-    onBehalfOf?: Reference<"Organization">;
+    onBehalfOf?: Reference<'Organization'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Procedure.js b/vendor/r4/types/hl7-fhir-r4-core/Procedure.js
index c8ad2e5..372a4dc 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Procedure.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Procedure.js
@@ -1,2 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcedureStatus = void 0;
+/** preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown */
+var ProcedureStatus;
+(function (ProcedureStatus) {
+    ProcedureStatus["Completed"] = "completed";
+    ProcedureStatus["EnteredInError"] = "entered-in-error";
+    ProcedureStatus["InProgress"] = "in-progress";
+    ProcedureStatus["NotDone"] = "not-done";
+    ProcedureStatus["OnHold"] = "on-hold";
+    ProcedureStatus["Preparation"] = "preparation";
+    ProcedureStatus["Stopped"] = "stopped";
+    ProcedureStatus["Unknown"] = "unknown";
+})(ProcedureStatus = exports.ProcedureStatus || (exports.ProcedureStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Provenance.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Provenance.d.ts
index cc09552..bc0a689 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Provenance.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Provenance.d.ts
@@ -9,10 +9,10 @@ import { DomainResource } from "./DomainResource";
 import { instant } from "./instant";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies. */
 export interface Provenance extends DomainResource {
+    resourceType: 'Provenance';
     _occurredDateTime?: Element;
     /** Signature on target */
     signature?: Array<Signature>;
@@ -31,15 +31,23 @@ export interface Provenance extends DomainResource {
     target: Array<Reference>;
     _recorded?: Element;
     /** Where the activity occurred, if relevant */
-    location?: Reference<"Location">;
+    location?: Reference<'Location'>;
     /** An entity used in this activity */
     entity?: Array<ProvenanceEntity>;
     occurredPeriod?: Period;
 }
+/** derivation | revision | quotation | source | removal */
+export declare enum ProvenanceRole {
+    Derivation = "derivation",
+    Quotation = "quotation",
+    Removal = "removal",
+    Revision = "revision",
+    Source = "source"
+}
 /** An entity used in this activity */
 export interface ProvenanceEntity extends BackboneElement {
     /** derivation | revision | quotation | source | removal */
-    role: code;
+    role: `${ProvenanceRole}`;
     _role?: Element;
     /** Identity of entity */
     what: Reference;
@@ -53,7 +61,7 @@ export interface ProvenanceAgent extends BackboneElement {
     /** What the agents role was */
     role?: Array<CodeableConcept>;
     /** Who participated */
-    who: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    who: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** Who the agent is representing */
-    onBehalfOf?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    onBehalfOf?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Provenance.js b/vendor/r4/types/hl7-fhir-r4-core/Provenance.js
index c8ad2e5..57e4864 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Provenance.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Provenance.js
@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProvenanceRole = void 0;
+/** derivation | revision | quotation | source | removal */
+var ProvenanceRole;
+(function (ProvenanceRole) {
+    ProvenanceRole["Derivation"] = "derivation";
+    ProvenanceRole["Quotation"] = "quotation";
+    ProvenanceRole["Removal"] = "removal";
+    ProvenanceRole["Revision"] = "revision";
+    ProvenanceRole["Source"] = "source";
+})(ProvenanceRole = exports.ProvenanceRole || (exports.ProvenanceRole = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Quantity.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Quantity.d.ts
index 95f6285..2795c70 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Quantity.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Quantity.d.ts
@@ -18,7 +18,14 @@ export interface Quantity extends Element {
     /** Coded form of the unit */
     code?: code;
     /** < | <= | >= | > - how to understand the value */
-    comparator?: code;
+    comparator?: `${QuantityComparator}`;
     _system?: Element;
     _unit?: Element;
 }
+/** < | <= | >= | > - how to understand the value */
+export declare enum QuantityComparator {
+    "<" = "<",
+    "<=" = "<=",
+    ">" = ">",
+    ">=" = ">="
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Quantity.js b/vendor/r4/types/hl7-fhir-r4-core/Quantity.js
index c8ad2e5..b7fb785 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Quantity.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Quantity.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuantityComparator = void 0;
+/** < | <= | >= | > - how to understand the value */
+var QuantityComparator;
+(function (QuantityComparator) {
+    QuantityComparator["<"] = "<";
+    QuantityComparator["<="] = "<=";
+    QuantityComparator[">"] = ">";
+    QuantityComparator[">="] = ">=";
+})(QuantityComparator = exports.QuantityComparator || (exports.QuantityComparator = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Questionnaire.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Questionnaire.d.ts
index cb03447..be92d6c 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Questionnaire.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Questionnaire.d.ts
@@ -23,6 +23,7 @@ import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection. */
 export interface Questionnaire extends DomainResource {
+    resourceType: 'Questionnaire';
     /** Natural language description of the questionnaire */
     description?: markdown;
     /** Resource that can be subject of QuestionnaireResponse */
@@ -60,7 +61,7 @@ export interface Questionnaire extends DomainResource {
     _purpose?: Element;
     _lastReviewDate?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${QuestionnaireStatus}`;
     _name?: Element;
     /** Canonical identifier for this questionnaire, represented as a URI (globally unique) */
     url?: uri;
@@ -82,6 +83,48 @@ export interface Questionnaire extends DomainResource {
     /** When the questionnaire is expected to be used */
     effectivePeriod?: Period;
 }
+/** draft | active | retired | unknown */
+export declare enum QuestionnaireStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** all | any */
+export declare enum QuestionnaireItemEnableBehavior {
+    All = "all",
+    Any = "any"
+}
+/** group | display | boolean | decimal | integer | date | dateTime + */
+export declare enum QuestionnaireItemType {
+    Display = "display",
+    Attachment = "attachment",
+    Question = "question",
+    Date = "date",
+    Decimal = "decimal",
+    Url = "url",
+    Quantity = "quantity",
+    Choice = "choice",
+    Integer = "integer",
+    String = "string",
+    Text = "text",
+    Group = "group",
+    Reference = "reference",
+    OpenChoice = "open-choice",
+    Time = "time",
+    DateTime = "dateTime",
+    Boolean = "boolean"
+}
+/** exists | = | != | > | < | >= | <= */
+export declare enum QuestionnaireItemOperator {
+    "!=" = "!=",
+    "<" = "<",
+    "<=" = "<=",
+    "=" = "=",
+    ">" = ">",
+    ">=" = ">=",
+    Exists = "exists"
+}
 /** Only allow data when */
 export interface QuestionnaireItemEnableWhen extends BackboneElement {
     _question?: Element;
@@ -100,7 +143,7 @@ export interface QuestionnaireItemEnableWhen extends BackboneElement {
     _answerDecimal: Element;
     answerString: string;
     /** exists | = | != | > | < | >= | <= */
-    operator: code;
+    operator: `${QuestionnaireItemOperator}`;
     _answerDateTime: Element;
     answerBoolean: boolean;
     answerCoding: Coding;
@@ -150,7 +193,7 @@ export interface QuestionnaireItemInitial extends BackboneElement {
 /** Questions and sections within the Questionnaire */
 export interface QuestionnaireItem extends BackboneElement {
     /** all | any */
-    enableBehavior?: code;
+    enableBehavior?: `${QuestionnaireItemEnableBehavior}`;
     /** ElementDefinition - details for the item */
     definition?: uri;
     _maxLength?: Element;
@@ -164,7 +207,7 @@ export interface QuestionnaireItem extends BackboneElement {
     item?: Array<QuestionnaireItem>;
     _type?: Element;
     /** group | display | boolean | decimal | integer | date | dateTime + */
-    type: code;
+    type: `${QuestionnaireItemType}`;
     _linkId?: Element;
     /** Only allow data when */
     enableWhen?: Array<QuestionnaireItemEnableWhen>;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Questionnaire.js b/vendor/r4/types/hl7-fhir-r4-core/Questionnaire.js
index c8ad2e5..9a48788 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Questionnaire.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Questionnaire.js
@@ -1,2 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionnaireItemOperator = exports.QuestionnaireItemType = exports.QuestionnaireItemEnableBehavior = exports.QuestionnaireStatus = void 0;
+/** draft | active | retired | unknown */
+var QuestionnaireStatus;
+(function (QuestionnaireStatus) {
+    QuestionnaireStatus["Active"] = "active";
+    QuestionnaireStatus["Draft"] = "draft";
+    QuestionnaireStatus["Retired"] = "retired";
+    QuestionnaireStatus["Unknown"] = "unknown";
+})(QuestionnaireStatus = exports.QuestionnaireStatus || (exports.QuestionnaireStatus = {}));
+/** all | any */
+var QuestionnaireItemEnableBehavior;
+(function (QuestionnaireItemEnableBehavior) {
+    QuestionnaireItemEnableBehavior["All"] = "all";
+    QuestionnaireItemEnableBehavior["Any"] = "any";
+})(QuestionnaireItemEnableBehavior = exports.QuestionnaireItemEnableBehavior || (exports.QuestionnaireItemEnableBehavior = {}));
+/** group | display | boolean | decimal | integer | date | dateTime + */
+var QuestionnaireItemType;
+(function (QuestionnaireItemType) {
+    QuestionnaireItemType["Display"] = "display";
+    QuestionnaireItemType["Attachment"] = "attachment";
+    QuestionnaireItemType["Question"] = "question";
+    QuestionnaireItemType["Date"] = "date";
+    QuestionnaireItemType["Decimal"] = "decimal";
+    QuestionnaireItemType["Url"] = "url";
+    QuestionnaireItemType["Quantity"] = "quantity";
+    QuestionnaireItemType["Choice"] = "choice";
+    QuestionnaireItemType["Integer"] = "integer";
+    QuestionnaireItemType["String"] = "string";
+    QuestionnaireItemType["Text"] = "text";
+    QuestionnaireItemType["Group"] = "group";
+    QuestionnaireItemType["Reference"] = "reference";
+    QuestionnaireItemType["OpenChoice"] = "open-choice";
+    QuestionnaireItemType["Time"] = "time";
+    QuestionnaireItemType["DateTime"] = "dateTime";
+    QuestionnaireItemType["Boolean"] = "boolean";
+})(QuestionnaireItemType = exports.QuestionnaireItemType || (exports.QuestionnaireItemType = {}));
+/** exists | = | != | > | < | >= | <= */
+var QuestionnaireItemOperator;
+(function (QuestionnaireItemOperator) {
+    QuestionnaireItemOperator["!="] = "!=";
+    QuestionnaireItemOperator["<"] = "<";
+    QuestionnaireItemOperator["<="] = "<=";
+    QuestionnaireItemOperator["="] = "=";
+    QuestionnaireItemOperator[">"] = ">";
+    QuestionnaireItemOperator[">="] = ">=";
+    QuestionnaireItemOperator["Exists"] = "exists";
+})(QuestionnaireItemOperator = exports.QuestionnaireItemOperator || (exports.QuestionnaireItemOperator = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/QuestionnaireResponse.d.ts b/vendor/r4/types/hl7-fhir-r4-core/QuestionnaireResponse.d.ts
index 2c2283f..868cd58 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/QuestionnaireResponse.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/QuestionnaireResponse.d.ts
@@ -12,25 +12,25 @@ import { DomainResource } from "./DomainResource";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to. */
 export interface QuestionnaireResponse extends DomainResource {
+    resourceType: 'QuestionnaireResponse';
     /** Form being answered */
     questionnaire?: canonical;
     /** Encounter created as part of */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     item?: Array<QuestionnaireResponseItem>;
     _status?: Element;
     _authored?: Element;
     /** The person who answered the questions */
-    source?: Reference<"Patient" | "PractitionerRole" | "Practitioner" | "RelatedPerson">;
+    source?: Reference<'Patient' | 'PractitionerRole' | 'Practitioner' | 'RelatedPerson'>;
     /** Person who received and recorded the answers */
-    author?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    author?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** in-progress | completed | amended | entered-in-error | stopped */
-    status: code;
+    status: `${QuestionnaireResponseStatus}`;
     /** Unique id for this set of answers */
     identifier?: Identifier;
     /** Request fulfilled by this QuestionnaireResponse */
@@ -43,6 +43,14 @@ export interface QuestionnaireResponse extends DomainResource {
     subject?: Reference;
     _questionnaire?: Element;
 }
+/** in-progress | completed | amended | entered-in-error | stopped */
+export declare enum QuestionnaireResponseStatus {
+    Amended = "amended",
+    Completed = "completed",
+    EnteredInError = "entered-in-error",
+    InProgress = "in-progress",
+    Stopped = "stopped"
+}
 /** The response(s) to the question */
 export interface QuestionnaireResponseItemAnswer extends BackboneElement {
     _valueUri?: Element;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/QuestionnaireResponse.js b/vendor/r4/types/hl7-fhir-r4-core/QuestionnaireResponse.js
index c8ad2e5..1e2fe5b 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/QuestionnaireResponse.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/QuestionnaireResponse.js
@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionnaireResponseStatus = void 0;
+/** in-progress | completed | amended | entered-in-error | stopped */
+var QuestionnaireResponseStatus;
+(function (QuestionnaireResponseStatus) {
+    QuestionnaireResponseStatus["Amended"] = "amended";
+    QuestionnaireResponseStatus["Completed"] = "completed";
+    QuestionnaireResponseStatus["EnteredInError"] = "entered-in-error";
+    QuestionnaireResponseStatus["InProgress"] = "in-progress";
+    QuestionnaireResponseStatus["Stopped"] = "stopped";
+})(QuestionnaireResponseStatus = exports.QuestionnaireResponseStatus || (exports.QuestionnaireResponseStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/RelatedArtifact.d.ts b/vendor/r4/types/hl7-fhir-r4-core/RelatedArtifact.d.ts
index 0ac7611..03b35c7 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/RelatedArtifact.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/RelatedArtifact.d.ts
@@ -5,12 +5,11 @@ import { url } from "./url";
 import { canonical } from "./canonical";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
-import { code } from "./code";
 /** Base StructureDefinition for RelatedArtifact Type: Related artifacts such as additional documentation, justification, or bibliographic references. */
 export interface RelatedArtifact extends Element {
     _type?: Element;
     /** documentation | justification | citation | predecessor | successor | derived-from | depends-on | composed-of */
-    type: code;
+    type: `${RelatedArtifactType}`;
     /** What document is being referenced */
     document?: Attachment;
     /** Bibliographic citation for the artifact */
@@ -29,3 +28,14 @@ export interface RelatedArtifact extends Element {
     _url?: Element;
     _display?: Element;
 }
+/** documentation | justification | citation | predecessor | successor | derived-from | depends-on | composed-of */
+export declare enum RelatedArtifactType {
+    Citation = "citation",
+    ComposedOf = "composed-of",
+    DependsOn = "depends-on",
+    DerivedFrom = "derived-from",
+    Documentation = "documentation",
+    Justification = "justification",
+    Predecessor = "predecessor",
+    Successor = "successor"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/RelatedArtifact.js b/vendor/r4/types/hl7-fhir-r4-core/RelatedArtifact.js
index c8ad2e5..9b9cb27 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/RelatedArtifact.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/RelatedArtifact.js
@@ -1,2 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelatedArtifactType = void 0;
+/** documentation | justification | citation | predecessor | successor | derived-from | depends-on | composed-of */
+var RelatedArtifactType;
+(function (RelatedArtifactType) {
+    RelatedArtifactType["Citation"] = "citation";
+    RelatedArtifactType["ComposedOf"] = "composed-of";
+    RelatedArtifactType["DependsOn"] = "depends-on";
+    RelatedArtifactType["DerivedFrom"] = "derived-from";
+    RelatedArtifactType["Documentation"] = "documentation";
+    RelatedArtifactType["Justification"] = "justification";
+    RelatedArtifactType["Predecessor"] = "predecessor";
+    RelatedArtifactType["Successor"] = "successor";
+})(RelatedArtifactType = exports.RelatedArtifactType || (exports.RelatedArtifactType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/RelatedPerson.d.ts b/vendor/r4/types/hl7-fhir-r4-core/RelatedPerson.d.ts
index fd9e666..0fccfbe 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/RelatedPerson.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/RelatedPerson.d.ts
@@ -10,13 +10,13 @@ import { DomainResource } from "./DomainResource";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Information about a person that is involved in the care for a patient, but who is not the target of healthcare, nor has a formal responsibility in the care process. */
 export interface RelatedPerson extends DomainResource {
+    resourceType: 'RelatedPerson';
     /** The patient this person is related to */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     _active?: Element;
     /** Address where the related person can be contacted or visited */
     address?: Array<Address>;
@@ -39,7 +39,7 @@ export interface RelatedPerson extends DomainResource {
     /** A contact detail for the person */
     telecom?: Array<ContactPoint>;
     /** male | female | other | unknown */
-    gender?: code;
+    gender?: `${RelatedPersonGender}`;
     /** Period of time that this relationship is considered valid */
     period?: Period;
 }
@@ -51,3 +51,10 @@ export interface RelatedPersonCommunication extends BackboneElement {
     preferred?: boolean;
     _preferred?: Element;
 }
+/** male | female | other | unknown */
+export declare enum RelatedPersonGender {
+    Female = "female",
+    Male = "male",
+    Other = "other",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/RelatedPerson.js b/vendor/r4/types/hl7-fhir-r4-core/RelatedPerson.js
index c8ad2e5..4d02190 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/RelatedPerson.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/RelatedPerson.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelatedPersonGender = void 0;
+/** male | female | other | unknown */
+var RelatedPersonGender;
+(function (RelatedPersonGender) {
+    RelatedPersonGender["Female"] = "female";
+    RelatedPersonGender["Male"] = "male";
+    RelatedPersonGender["Other"] = "other";
+    RelatedPersonGender["Unknown"] = "unknown";
+})(RelatedPersonGender = exports.RelatedPersonGender || (exports.RelatedPersonGender = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/RequestGroup.d.ts b/vendor/r4/types/hl7-fhir-r4-core/RequestGroup.d.ts
index 63b9729..bc177bc 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/RequestGroup.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/RequestGroup.d.ts
@@ -16,18 +16,18 @@ import { Duration } from "./Duration";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A group of related requests that can be used to capture intended activities that have inter-dependencies such as "give this medication after that one". */
 export interface RequestGroup extends DomainResource {
+    resourceType: 'RequestGroup';
     /** Instantiates FHIR protocol or definition */
     instantiatesCanonical?: Array<canonical>;
     /** Instantiates external protocol or definition */
     instantiatesUri?: Array<uri>;
     _authoredOn?: Element;
     /** Created as part of */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _priority?: Element;
     _status?: Element;
     /** Why the request group is needed */
@@ -37,12 +37,12 @@ export interface RequestGroup extends DomainResource {
     /** Additional notes about the response */
     note?: Array<Annotation>;
     /** Device or practitioner that authored the request group */
-    author?: Reference<"PractitionerRole" | "Device" | "Practitioner">;
+    author?: Reference<'PractitionerRole' | 'Device' | 'Practitioner'>;
     _intent?: Element;
     /** routine | urgent | asap | stat */
-    priority?: code;
+    priority?: `${RequestGroupPriority}`;
     /** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
-    status: code;
+    status: `${RequestGroupStatus}`;
     /** Composite request this is part of */
     groupIdentifier?: Identifier;
     /** What's being requested/ordered */
@@ -50,7 +50,7 @@ export interface RequestGroup extends DomainResource {
     /** Business identifier */
     identifier?: Array<Identifier>;
     /** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
-    intent: code;
+    intent: `${RequestGroupIntent}`;
     action?: Array<RequestGroupAction>;
     /** Request(s) replaced by this request */
     replaces?: Array<Reference>;
@@ -58,30 +58,90 @@ export interface RequestGroup extends DomainResource {
     basedOn?: Array<Reference>;
     _instantiatesCanonical?: Array<Element>;
     /** Who the request group is about */
-    subject?: Reference<"Patient" | "Group">;
+    subject?: Reference<'Patient' | 'Group'>;
     /** Why the request group is needed */
     reasonReference?: Array<Reference>;
     _instantiatesUri?: Array<Element>;
 }
+/** routine | urgent | asap | stat */
+export declare enum RequestGroupActionPriority {
+    Asap = "asap",
+    Routine = "routine",
+    Stat = "stat",
+    Urgent = "urgent"
+}
+/** yes | no */
+export declare enum RequestGroupActionPrecheckBehavior {
+    No = "no",
+    Yes = "yes"
+}
+/** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
+export declare enum RequestGroupIntent {
+    Order = "order",
+    FillerOrder = "filler-order",
+    Option = "option",
+    Directive = "directive",
+    Proposal = "proposal",
+    ReflexOrder = "reflex-order",
+    Plan = "plan",
+    InstanceOrder = "instance-order",
+    OriginalOrder = "original-order"
+}
+/** single | multiple */
+export declare enum RequestGroupActionCardinalityBehavior {
+    Multiple = "multiple",
+    Single = "single"
+}
+/** any | all | all-or-none | exactly-one | at-most-one | one-or-more */
+export declare enum RequestGroupActionSelectionBehavior {
+    All = "all",
+    AllOrNone = "all-or-none",
+    Any = "any",
+    AtMostOne = "at-most-one",
+    ExactlyOne = "exactly-one",
+    OneOrMore = "one-or-more"
+}
+/** before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end */
+export declare enum RequestGroupActionRelationship {
+    BeforeStart = "before-start",
+    Concurrent = "concurrent",
+    After = "after",
+    ConcurrentWithStart = "concurrent-with-start",
+    BeforeEnd = "before-end",
+    AfterEnd = "after-end",
+    AfterStart = "after-start",
+    Before = "before",
+    ConcurrentWithEnd = "concurrent-with-end"
+}
+/** Whether or not the action is applicable */
+export interface RequestGroupActionCondition extends BackboneElement {
+    /** applicability | start | stop */
+    kind: `${RequestGroupActionKind}`;
+    _kind?: Element;
+    /** Boolean-valued expression */
+    expression?: Expression;
+}
+/** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
+export declare enum RequestGroupStatus {
+    Active = "active",
+    Completed = "completed",
+    Draft = "draft",
+    EnteredInError = "entered-in-error",
+    OnHold = "on-hold",
+    Revoked = "revoked",
+    Unknown = "unknown"
+}
 /** Relationship to another action */
 export interface RequestGroupActionRelatedAction extends BackboneElement {
     /** What action this is related to */
     actionId: id;
     _actionId?: Element;
     /** before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end */
-    relationship: code;
+    relationship: `${RequestGroupActionRelationship}`;
     _relationship?: Element;
     offsetDuration?: Duration;
     offsetRange?: Range;
 }
-/** Whether or not the action is applicable */
-export interface RequestGroupActionCondition extends BackboneElement {
-    /** applicability | start | stop */
-    kind: code;
-    _kind?: Element;
-    /** Boolean-valued expression */
-    expression?: Expression;
-}
 /** Proposed actions, if any */
 export interface RequestGroupAction extends BackboneElement {
     _groupingBehavior?: Element;
@@ -109,20 +169,20 @@ export interface RequestGroupAction extends BackboneElement {
     /** User-visible prefix for the action (e.g. 1. or A.) */
     prefix?: string;
     /** any | all | all-or-none | exactly-one | at-most-one | one-or-more */
-    selectionBehavior?: code;
+    selectionBehavior?: `${RequestGroupActionSelectionBehavior}`;
     timingDateTime?: dateTime;
     timingTiming?: Timing;
     timingDuration?: Duration;
     /** routine | urgent | asap | stat */
-    priority?: code;
+    priority?: `${RequestGroupActionPriority}`;
     /** must | could | must-unless-documented */
-    requiredBehavior?: code;
+    requiredBehavior?: `${RequestGroupActionRequiredBehavior}`;
     /** Whether or not the action is applicable */
     condition?: Array<RequestGroupActionCondition>;
     /** The target of the action */
     resource?: Reference;
     /** visual-group | logical-group | sentence-group */
-    groupingBehavior?: code;
+    groupingBehavior?: `${RequestGroupActionGroupingBehavior}`;
     /** Code representing the meaning of the action or sub-actions */
     code?: Array<CodeableConcept>;
     timingAge?: Age;
@@ -131,10 +191,35 @@ export interface RequestGroupAction extends BackboneElement {
     action?: Array<RequestGroupAction>;
     _selectionBehavior?: Element;
     /** yes | no */
-    precheckBehavior?: code;
+    precheckBehavior?: `${RequestGroupActionPrecheckBehavior}`;
     _title?: Element;
     _cardinalityBehavior?: Element;
     _textEquivalent?: Element;
     /** single | multiple */
-    cardinalityBehavior?: code;
+    cardinalityBehavior?: `${RequestGroupActionCardinalityBehavior}`;
+}
+/** applicability | start | stop */
+export declare enum RequestGroupActionKind {
+    Applicability = "applicability",
+    Start = "start",
+    Stop = "stop"
+}
+/** visual-group | logical-group | sentence-group */
+export declare enum RequestGroupActionGroupingBehavior {
+    LogicalGroup = "logical-group",
+    SentenceGroup = "sentence-group",
+    VisualGroup = "visual-group"
+}
+/** routine | urgent | asap | stat */
+export declare enum RequestGroupPriority {
+    Asap = "asap",
+    Routine = "routine",
+    Stat = "stat",
+    Urgent = "urgent"
+}
+/** must | could | must-unless-documented */
+export declare enum RequestGroupActionRequiredBehavior {
+    Could = "could",
+    Must = "must",
+    MustUnlessDocumented = "must-unless-documented"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/RequestGroup.js b/vendor/r4/types/hl7-fhir-r4-core/RequestGroup.js
index c8ad2e5..9eb12da 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/RequestGroup.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/RequestGroup.js
@@ -1,2 +1,99 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestGroupActionRequiredBehavior = exports.RequestGroupPriority = exports.RequestGroupActionGroupingBehavior = exports.RequestGroupActionKind = exports.RequestGroupStatus = exports.RequestGroupActionRelationship = exports.RequestGroupActionSelectionBehavior = exports.RequestGroupActionCardinalityBehavior = exports.RequestGroupIntent = exports.RequestGroupActionPrecheckBehavior = exports.RequestGroupActionPriority = void 0;
+/** routine | urgent | asap | stat */
+var RequestGroupActionPriority;
+(function (RequestGroupActionPriority) {
+    RequestGroupActionPriority["Asap"] = "asap";
+    RequestGroupActionPriority["Routine"] = "routine";
+    RequestGroupActionPriority["Stat"] = "stat";
+    RequestGroupActionPriority["Urgent"] = "urgent";
+})(RequestGroupActionPriority = exports.RequestGroupActionPriority || (exports.RequestGroupActionPriority = {}));
+/** yes | no */
+var RequestGroupActionPrecheckBehavior;
+(function (RequestGroupActionPrecheckBehavior) {
+    RequestGroupActionPrecheckBehavior["No"] = "no";
+    RequestGroupActionPrecheckBehavior["Yes"] = "yes";
+})(RequestGroupActionPrecheckBehavior = exports.RequestGroupActionPrecheckBehavior || (exports.RequestGroupActionPrecheckBehavior = {}));
+/** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
+var RequestGroupIntent;
+(function (RequestGroupIntent) {
+    RequestGroupIntent["Order"] = "order";
+    RequestGroupIntent["FillerOrder"] = "filler-order";
+    RequestGroupIntent["Option"] = "option";
+    RequestGroupIntent["Directive"] = "directive";
+    RequestGroupIntent["Proposal"] = "proposal";
+    RequestGroupIntent["ReflexOrder"] = "reflex-order";
+    RequestGroupIntent["Plan"] = "plan";
+    RequestGroupIntent["InstanceOrder"] = "instance-order";
+    RequestGroupIntent["OriginalOrder"] = "original-order";
+})(RequestGroupIntent = exports.RequestGroupIntent || (exports.RequestGroupIntent = {}));
+/** single | multiple */
+var RequestGroupActionCardinalityBehavior;
+(function (RequestGroupActionCardinalityBehavior) {
+    RequestGroupActionCardinalityBehavior["Multiple"] = "multiple";
+    RequestGroupActionCardinalityBehavior["Single"] = "single";
+})(RequestGroupActionCardinalityBehavior = exports.RequestGroupActionCardinalityBehavior || (exports.RequestGroupActionCardinalityBehavior = {}));
+/** any | all | all-or-none | exactly-one | at-most-one | one-or-more */
+var RequestGroupActionSelectionBehavior;
+(function (RequestGroupActionSelectionBehavior) {
+    RequestGroupActionSelectionBehavior["All"] = "all";
+    RequestGroupActionSelectionBehavior["AllOrNone"] = "all-or-none";
+    RequestGroupActionSelectionBehavior["Any"] = "any";
+    RequestGroupActionSelectionBehavior["AtMostOne"] = "at-most-one";
+    RequestGroupActionSelectionBehavior["ExactlyOne"] = "exactly-one";
+    RequestGroupActionSelectionBehavior["OneOrMore"] = "one-or-more";
+})(RequestGroupActionSelectionBehavior = exports.RequestGroupActionSelectionBehavior || (exports.RequestGroupActionSelectionBehavior = {}));
+/** before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end */
+var RequestGroupActionRelationship;
+(function (RequestGroupActionRelationship) {
+    RequestGroupActionRelationship["BeforeStart"] = "before-start";
+    RequestGroupActionRelationship["Concurrent"] = "concurrent";
+    RequestGroupActionRelationship["After"] = "after";
+    RequestGroupActionRelationship["ConcurrentWithStart"] = "concurrent-with-start";
+    RequestGroupActionRelationship["BeforeEnd"] = "before-end";
+    RequestGroupActionRelationship["AfterEnd"] = "after-end";
+    RequestGroupActionRelationship["AfterStart"] = "after-start";
+    RequestGroupActionRelationship["Before"] = "before";
+    RequestGroupActionRelationship["ConcurrentWithEnd"] = "concurrent-with-end";
+})(RequestGroupActionRelationship = exports.RequestGroupActionRelationship || (exports.RequestGroupActionRelationship = {}));
+/** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
+var RequestGroupStatus;
+(function (RequestGroupStatus) {
+    RequestGroupStatus["Active"] = "active";
+    RequestGroupStatus["Completed"] = "completed";
+    RequestGroupStatus["Draft"] = "draft";
+    RequestGroupStatus["EnteredInError"] = "entered-in-error";
+    RequestGroupStatus["OnHold"] = "on-hold";
+    RequestGroupStatus["Revoked"] = "revoked";
+    RequestGroupStatus["Unknown"] = "unknown";
+})(RequestGroupStatus = exports.RequestGroupStatus || (exports.RequestGroupStatus = {}));
+/** applicability | start | stop */
+var RequestGroupActionKind;
+(function (RequestGroupActionKind) {
+    RequestGroupActionKind["Applicability"] = "applicability";
+    RequestGroupActionKind["Start"] = "start";
+    RequestGroupActionKind["Stop"] = "stop";
+})(RequestGroupActionKind = exports.RequestGroupActionKind || (exports.RequestGroupActionKind = {}));
+/** visual-group | logical-group | sentence-group */
+var RequestGroupActionGroupingBehavior;
+(function (RequestGroupActionGroupingBehavior) {
+    RequestGroupActionGroupingBehavior["LogicalGroup"] = "logical-group";
+    RequestGroupActionGroupingBehavior["SentenceGroup"] = "sentence-group";
+    RequestGroupActionGroupingBehavior["VisualGroup"] = "visual-group";
+})(RequestGroupActionGroupingBehavior = exports.RequestGroupActionGroupingBehavior || (exports.RequestGroupActionGroupingBehavior = {}));
+/** routine | urgent | asap | stat */
+var RequestGroupPriority;
+(function (RequestGroupPriority) {
+    RequestGroupPriority["Asap"] = "asap";
+    RequestGroupPriority["Routine"] = "routine";
+    RequestGroupPriority["Stat"] = "stat";
+    RequestGroupPriority["Urgent"] = "urgent";
+})(RequestGroupPriority = exports.RequestGroupPriority || (exports.RequestGroupPriority = {}));
+/** must | could | must-unless-documented */
+var RequestGroupActionRequiredBehavior;
+(function (RequestGroupActionRequiredBehavior) {
+    RequestGroupActionRequiredBehavior["Could"] = "could";
+    RequestGroupActionRequiredBehavior["Must"] = "must";
+    RequestGroupActionRequiredBehavior["MustUnlessDocumented"] = "must-unless-documented";
+})(RequestGroupActionRequiredBehavior = exports.RequestGroupActionRequiredBehavior || (exports.RequestGroupActionRequiredBehavior = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ResearchDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ResearchDefinition.d.ts
index ffcdd8c..ffca445 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ResearchDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ResearchDefinition.d.ts
@@ -13,15 +13,15 @@ import { date } from "./date";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** The ResearchDefinition resource describes the conditional state (population and any exposures being compared within the population) and outcome (if specified) that the knowledge (evidence, assertion, recommendation) is about. */
 export interface ResearchDefinition extends DomainResource {
+    resourceType: 'ResearchDefinition';
     /** Natural language description of the research definition */
     description?: markdown;
     _usage?: Element;
     /** What alternative exposure state? */
-    exposureAlternative?: Reference<"ResearchElementDefinition">;
+    exposureAlternative?: Reference<'ResearchElementDefinition'>;
     /** Date last changed */
     date?: dateTime;
     /** Who endorsed the content */
@@ -49,7 +49,7 @@ export interface ResearchDefinition extends DomainResource {
     /** For testing purposes, not real usage */
     experimental?: boolean;
     /** What outcome? */
-    outcome?: Reference<"ResearchElementDefinition">;
+    outcome?: Reference<'ResearchElementDefinition'>;
     /** The category of the ResearchDefinition, such as Education, Treatment, Assessment, etc. */
     topic?: Array<CodeableConcept>;
     /** Name for this research definition (human friendly) */
@@ -64,11 +64,11 @@ export interface ResearchDefinition extends DomainResource {
     usage?: string;
     _lastReviewDate?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${ResearchDefinitionStatus}`;
     /** Subordinate title of the ResearchDefinition */
     subtitle?: string;
     /** What population? */
-    population: Reference<"ResearchElementDefinition">;
+    population: Reference<'ResearchElementDefinition'>;
     /** Used for footnotes or explanatory notes */
     comment?: Array<string>;
     _name?: Element;
@@ -90,7 +90,7 @@ export interface ResearchDefinition extends DomainResource {
     /** Title for use in informal contexts */
     shortTitle?: string;
     /** What exposure? */
-    exposure?: Reference<"ResearchElementDefinition">;
+    exposure?: Reference<'ResearchElementDefinition'>;
     /** Business version of the research definition */
     version?: string;
     _version?: Element;
@@ -98,9 +98,16 @@ export interface ResearchDefinition extends DomainResource {
     relatedArtifact?: Array<RelatedArtifact>;
     /** Contact details for the publisher */
     contact?: Array<ContactDetail>;
-    subjectReference?: Reference<"Group">;
+    subjectReference?: Reference<'Group'>;
     _comment?: Array<Element>;
     _url?: Element;
     /** When the research definition is expected to be used */
     effectivePeriod?: Period;
 }
+/** draft | active | retired | unknown */
+export declare enum ResearchDefinitionStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ResearchDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/ResearchDefinition.js
index c8ad2e5..9cdb5c9 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ResearchDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ResearchDefinition.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResearchDefinitionStatus = void 0;
+/** draft | active | retired | unknown */
+var ResearchDefinitionStatus;
+(function (ResearchDefinitionStatus) {
+    ResearchDefinitionStatus["Active"] = "active";
+    ResearchDefinitionStatus["Draft"] = "draft";
+    ResearchDefinitionStatus["Retired"] = "retired";
+    ResearchDefinitionStatus["Unknown"] = "unknown";
+})(ResearchDefinitionStatus = exports.ResearchDefinitionStatus || (exports.ResearchDefinitionStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ResearchElementDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ResearchElementDefinition.d.ts
index c3feb7f..951590f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ResearchElementDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ResearchElementDefinition.d.ts
@@ -17,11 +17,11 @@ import { date } from "./date";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** The ResearchElementDefinition resource describes a "PICO" element that knowledge (evidence, assertion, recommendation) is about. */
 export interface ResearchElementDefinition extends DomainResource {
+    resourceType: 'ResearchElementDefinition';
     /** Natural language description of the research element definition */
     description?: markdown;
     _usage?: Element;
@@ -34,7 +34,7 @@ export interface ResearchElementDefinition extends DomainResource {
     /** When the research element definition was approved by publisher */
     approvalDate?: date;
     /** dichotomous | continuous | descriptive */
-    variableType?: code;
+    variableType?: `${ResearchElementDefinitionVariableType}`;
     /** Intended jurisdiction for research element definition (if applicable) */
     jurisdiction?: Array<CodeableConcept>;
     _publisher?: Element;
@@ -53,7 +53,7 @@ export interface ResearchElementDefinition extends DomainResource {
     copyright?: markdown;
     _approvalDate?: Element;
     /** population | exposure | outcome */
-    type: code;
+    type: `${ResearchElementDefinitionType}`;
     /** For testing purposes, not real usage */
     experimental?: boolean;
     /** The category of the ResearchElementDefinition, such as Education, Treatment, Assessment, etc. */
@@ -72,7 +72,7 @@ export interface ResearchElementDefinition extends DomainResource {
     usage?: string;
     _lastReviewDate?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${ResearchElementDefinitionStatus}`;
     /** Subordinate title of the ResearchElementDefinition */
     subtitle?: string;
     /** Used for footnotes or explanatory notes */
@@ -103,12 +103,1455 @@ export interface ResearchElementDefinition extends DomainResource {
     _variableType?: Element;
     /** Contact details for the publisher */
     contact?: Array<ContactDetail>;
-    subjectReference?: Reference<"Group">;
+    subjectReference?: Reference<'Group'>;
     _comment?: Array<Element>;
     _url?: Element;
     /** When the research element definition is expected to be used */
     effectivePeriod?: Period;
 }
+/** dichotomous | continuous | descriptive */
+export declare enum ResearchElementDefinitionVariableType {
+    Continuous = "continuous",
+    Descriptive = "descriptive",
+    Dichotomous = "dichotomous"
+}
+/** population | exposure | outcome */
+export declare enum ResearchElementDefinitionType {
+    Exposure = "exposure",
+    Outcome = "outcome",
+    Population = "population"
+}
+/** mean | median | mean-of-mean | mean-of-median | median-of-mean | median-of-median */
+export declare enum ResearchElementDefinitionStudyEffectiveGroupMeasure {
+    Mean = "mean",
+    MeanOfMean = "mean-of-mean",
+    MeanOfMedian = "mean-of-median",
+    Median = "median",
+    MedianOfMean = "median-of-mean",
+    MedianOfMedian = "median-of-median"
+}
+/** mean | median | mean-of-mean | mean-of-median | median-of-mean | median-of-median */
+export declare enum ResearchElementDefinitionParticipantEffectiveGroupMeasure {
+    Mean = "mean",
+    MeanOfMean = "mean-of-mean",
+    MeanOfMedian = "mean-of-median",
+    Median = "median",
+    MedianOfMean = "median-of-mean",
+    MedianOfMedian = "median-of-median"
+}
+/** What unit is the outcome described in? */
+export declare enum ResearchElementDefinitionUnitOfMeasure {
+    "Mo_j" = "mo_j",
+    CSt = "cSt",
+    "%{breakdown}" = "%{breakdown}",
+    "{rel_saturation}" = "{rel_saturation}",
+    "Fmol/g" = "fmol/g",
+    "{Pouches}/wk" = "{Pouches}/wk",
+    "Umol/mL" = "umol/mL",
+    "Kg/s" = "kg/s",
+    Bq = "Bq",
+    KPa = "kPa",
+    "Mosm/kg" = "mosm/kg",
+    "Mg/L" = "mg/L",
+    "Meq/kg" = "meq/kg",
+    "Nmol/(24.h)" = "nmol/(24.h)",
+    "U/mol" = "U/mol",
+    T = "T",
+    "K[IU]/mL" = "k[IU]/mL",
+    "B[V]" = "B[V]",
+    "Pmol/g" = "pmol/g",
+    "Num10*5" = "10*5",
+    Cm = "cm",
+    "{WhiteBloodCell}" = "{WhiteBloodCell}",
+    "{MPS'U}" = "{MPS'U}",
+    "Nmol/g{dry_wt}" = "nmol/g{dry_wt}",
+    Gf = "gf",
+    "{MPortionPhospholipids}" = "{M-PortionPhospholipids}",
+    "{titer}" = "{titer}",
+    "/g" = "/g",
+    "{Breaths}/min" = "{Breaths}/min",
+    "KU/mL" = "kU/mL",
+    "[rd_us]" = "[rd_us]",
+    "U{37Cel}/L" = "U{37Cel}/L",
+    "Pmol/H/mg{protein}" = "pmol/H/mg{protein}",
+    "[fth_us]" = "[fth_us]",
+    "Fmol/mg{cyt_prot}" = "fmol/mg{cyt_prot}",
+    "G/(kg.h)" = "g/(kg.h)",
+    "%{vol}" = "%{vol}",
+    "/{entity}" = "/{entity}",
+    "Mol/mol" = "mol/mol",
+    "Umol/h/g" = "umol/h/g",
+    Dm = "dm",
+    "[ston_av]" = "[ston_av]",
+    "G/g{Cre}" = "g/g{Cre}",
+    "%{Inhibition}" = "%{Inhibition}",
+    Mol = "mol",
+    "Pmol/h/mg{prot}" = "pmol/h/mg{prot}",
+    K = "K",
+    "{ComplementActivityEnzyme'U}" = "{ComplementActivityEnzyme'U}",
+    "%{WeightToWeight}" = "%{WeightToWeight}",
+    "%{bacteria}" = "%{bacteria}",
+    "Mg/(8.h.kg)" = "mg/(8.h.kg)",
+    "Cm[H2O]/(s.m)" = "cm[H2O]/(s.m)",
+    "[smi_us]" = "[smi_us]",
+    "Nmol/min" = "nmol/min",
+    "%{Bound}" = "%{Bound}",
+    "G/kg" = "g/kg",
+    Att = "att",
+    "Mg/L{RBCs}" = "mg/L{RBCs}",
+    "ML/(72.h)" = "mL/(72.h)",
+    "G.m/{hb}" = "g.m/{hb}",
+    "Ug/m2" = "ug/m2",
+    "Pmol/umol" = "pmol/umol",
+    "Meq/(kg.d)" = "meq/(kg.d)",
+    "Num10*3{Copies}/mL" = "10*3{Copies}/mL",
+    "Mg/kg/(24.h)" = "mg/kg/(24.h)",
+    "Mm[Hg]" = "mm[Hg]",
+    "Ug/dL{rbc}" = "ug/dL{rbc}",
+    "U/10*6" = "U/10*6",
+    "Ng/d" = "ng/d",
+    "[USP'U]" = "[USP'U]",
+    "Mmol/(2.h)" = "mmol/(2.h)",
+    "Num10.uN.s/(cm.m2)" = "10.uN.s/(cm.m2)",
+    "[in_us]" = "[in_us]",
+    Fmol = "fmol",
+    "Fmol/mg{protein}" = "fmol/mg{protein}",
+    "Nmol/L/mmol{creat}" = "nmol/L/mmol{creat}",
+    "[Btu]" = "[Btu]",
+    "Pmol/{RBC}" = "pmol/{RBC}",
+    "/10*3.{RBCs}" = "/10*3.{RBCs}",
+    "G/mmol{creat}" = "g/mmol{creat}",
+    "{AntibodyResponse'U}" = "{AntibodyResponse'U}",
+    "[IU]/kg" = "[IU]/kg",
+    "U/kg{hemoglobin}" = "U/kg{hemoglobin}",
+    "MU/mg" = "mU/mg",
+    "Cm[H2O]" = "cm[H2O]",
+    AU = "AU",
+    "Pg/{RBC}" = "pg/{RBC}",
+    "%{reactive}" = "%{reactive}",
+    "G/g{globulin}" = "g/g{globulin}",
+    "{cells}" = "{cells}",
+    "%{Live}" = "%{Live}",
+    "[pwt_tr]" = "[pwt_tr]",
+    "[ligne]" = "[ligne]",
+    "{IFA_index}" = "{IFA_index}",
+    "MU/mL/min" = "mU/mL/min",
+    "Num10*" = "10*",
+    "Pmol/min/mg{prot}" = "pmol/min/mg{prot}",
+    "[G]" = "[G]",
+    "ML/(24.h)" = "mL/(24.h)",
+    "[ka'U]" = "[ka'U]",
+    "G/L" = "g/L",
+    "/100" = "/100",
+    "Ng/mL{rbc}" = "ng/mL{rbc}",
+    st = "st",
+    "Umol/mol" = "umol/mol",
+    "Kat/L" = "kat/L",
+    "U/g{hemoglobin}" = "U/g{hemoglobin}",
+    "KU/L{class}" = "kU/L{class}",
+    "Pmol/mg{prot}" = "pmol/mg{prot}",
+    "Nmol/h/mg{protein}" = "nmol/h/mg{protein}",
+    "Num10*3{copies}/mL" = "10*3{copies}/mL",
+    "Mmol/h" = "mmol/h",
+    "[ppth]" = "[ppth]",
+    "{genomes}/mL" = "{genomes}/mL",
+    Mmol = "mmol",
+    Gon = "gon",
+    "Ng/dL/h" = "ng/dL/h",
+    "Mg/mmol" = "mg/mmol",
+    "Mg/mmol{Cre}" = "mg/mmol{Cre}",
+    "/100{neutrophils}" = "/100{neutrophils}",
+    "Mmol/(18.h)" = "mmol/(18.h)",
+    "Mmol/min" = "mmol/min",
+    "{spermatozoa}/mL" = "{spermatozoa}/mL",
+    "Mg/mg{Cre}" = "mg/mg{Cre}",
+    "Ng/kg/h" = "ng/kg/h",
+    "Ug/(kg.h)" = "ug/(kg.h)",
+    "{ToxoplasmaIndexValue}" = "{ToxoplasmaIndexValue}",
+    "/[IU]" = "/[IU]",
+    "/d" = "/d",
+    "Mg/(10.h)" = "mg/(10.h)",
+    "[cin_i]" = "[cin_i]",
+    "[oz_av]" = "[oz_av]",
+    "Ng/10*6" = "ng/10*6",
+    "%{HemoglobinA1C}" = "%{HemoglobinA1C}",
+    "{Ehrlich'U}/mL" = "{Ehrlich'U}/mL",
+    "{Applicator}" = "{Applicator}",
+    Pmol = "pmol",
+    "M[IU]/mL" = "m[IU]/mL",
+    "Mg/g{creat}" = "mg/g{creat}",
+    "U/mL" = "U/mL",
+    "[scwt_av]" = "[scwt_av]",
+    "[cicero]" = "[cicero]",
+    s = "s",
+    "Mmol/(5.h)" = "mmol/(5.h)",
+    "Pmol/h/mg{protein}" = "pmol/h/mg{protein}",
+    "{ElisaU}/mL" = "{ElisaU}/mL",
+    "Num10*12/L" = "10*12/L",
+    "G%" = "g%",
+    "Mol/mL" = "mol/mL",
+    "Meq/dL" = "meq/dL",
+    Lx = "lx",
+    "{Bottle}" = "{Bottle}",
+    "Nmol{ATP}" = "nmol{ATP}",
+    Lm = "lm",
+    "Ng/mL/h" = "ng/mL/h",
+    "Ug/g{Tissue}" = "ug/g{Tissue}",
+    "Umol/dL{GF}" = "umol/dL{GF}",
+    "/kg{body'wt}" = "/kg{body'wt}",
+    "{rbc}" = "{rbc}",
+    "Ug{T4}/dL" = "ug{T4}/dL",
+    "Umol/mmol" = "umol/mmol",
+    "Num10*3/uL" = "10*3/uL",
+    "{Log_copies}/mL" = "{Log_copies}/mL",
+    "Fmol/mg" = "fmol/mg",
+    "Lm/m2" = "lm/m2",
+    "%{blockade}" = "%{blockade}",
+    "Ug/mL{class}" = "ug/mL{class}",
+    "MU/min" = "mU/min",
+    Gy = "Gy",
+    "Num10*3" = "10*3",
+    "/[HPF]" = "/[HPF]",
+    "{M.o.M}" = "{M.o.M}",
+    "Pg/mL" = "pg/mL",
+    "{JDF'U}" = "{JDF'U}",
+    "A_t" = "a_t",
+    "Ug/g{Hgb}" = "ug/g{Hgb}",
+    "[sin_i]" = "[sin_i]",
+    "Pmol/h/mL" = "pmol/h/mL",
+    "U{25Cel}/L" = "U{25Cel}/L",
+    "Num10^" = "10^",
+    "{WBCs}" = "{WBCs}",
+    "{4 times}/d" = "{4 times}/d",
+    Ci = "Ci",
+    "Mg/g{tissue}" = "mg/g{tissue}",
+    "Ug/ng" = "ug/ng",
+    "[IU]/L{37Cel}" = "[IU]/L{37Cel}",
+    Pa = "Pa",
+    "{ERY}/uL" = "{ERY}/uL",
+    "Pmol/umol{creat}" = "pmol/umol{creat}",
+    "{binding_index}" = "{binding_index}",
+    MeV = "MeV",
+    "B[kW]" = "B[kW]",
+    "Mg/kg/d" = "mg/kg/d",
+    "/ug" = "/ug",
+    GBq = "GBq",
+    "Ug/(kg.d)" = "ug/(kg.d)",
+    "[tsp_us]" = "[tsp_us]",
+    "Mg/g{dry_tissue}" = "mg/g{dry_tissue}",
+    "/10*3" = "/10*3",
+    UOhm = "uOhm",
+    "ML/(8.h)" = "mL/(8.h)",
+    "/100{spermatozoa}" = "/100{spermatozoa}",
+    "Fmol/mL" = "fmol/mL",
+    "{# of fetuses}" = "{# of fetuses}",
+    "Ug/mL{eqv}" = "ug/mL{eqv}",
+    "{Packs}/d" = "{Packs}/d",
+    "[S]" = "[S]",
+    "G/min" = "g/min",
+    "Nmol/mol" = "nmol/mol",
+    MU = "mU",
+    Ug = "ug",
+    Ml = "ml",
+    "%[slope]" = "%[slope]",
+    "MU/mg{creat}" = "mU/mg{creat}",
+    "G.m/{beat}" = "g.m/{beat}",
+    "Num1/d" = "1/d",
+    "B[mV]" = "B[mV]",
+    MBq = "MBq",
+    UU = "uU",
+    "[PRU]" = "[PRU]",
+    "{Cells}/mL" = "{Cells}/mL",
+    "L/(min.m2)" = "L/(min.m2)",
+    "Ug/L" = "ug/L",
+    "Kg/m2" = "kg/m2",
+    "[smoot]" = "[smoot]",
+    "Ug/dL" = "ug/dL",
+    "[p'diop]" = "[p'diop]",
+    "Nmol/mg{prot}" = "nmol/mg{prot}",
+    "[ppm]" = "[ppm]",
+    "%{Total}" = "%{Total}",
+    "G/(24.h)" = "g/(24.h)",
+    "Num10*Num3{Polarization'U}" = "10*-3{Polarization'U}",
+    Pm = "pm",
+    "Umol/h/mg{protein}" = "umol/h/mg{protein}",
+    "G{total_prot}" = "g{total_prot}",
+    "/10*9" = "/10*9",
+    "/g{wet_tis}" = "/g{wet_tis}",
+    "%{inhibition}" = "%{inhibition}",
+    "/100{cells}" = "/100{cells}",
+    "Nmol/min/mg{prot}" = "nmol/min/mg{prot}",
+    "B[SPL]" = "B[SPL]",
+    "{Events}" = "{Events}",
+    "Ng/kg" = "ng/kg",
+    "[gal_br]" = "[gal_br]",
+    "/a" = "/a",
+    "Nmol/m/mg{prot}" = "nmol/m/mg{prot}",
+    "{#}/[LPF]" = "{#}/[LPF]",
+    "G/{total_weight}" = "g/{total_weight}",
+    "Nmol/mg{protein}" = "nmol/mg{protein}",
+    "[fdr_us]" = "[fdr_us]",
+    "Ug/mg" = "ug/mg",
+    "Ug/{specimen}" = "ug/{specimen}",
+    "U/(24.h)" = "U/(24.h)",
+    "Mmol/mmol" = "mmol/mmol",
+    "Mmol/kg/h" = "mmol/kg/h",
+    "Ug{FEU}/mL" = "ug{FEU}/mL",
+    ML = "mL",
+    "ML/[sin_i]" = "mL/[sin_i]",
+    "Num10*6/(24.h)" = "10*6/(24.h)",
+    "U/min" = "U/min",
+    "ML/d" = "mL/d",
+    "[APL'U]/mL" = "[APL'U]/mL",
+    "''" = "''",
+    "%{0to3Hours}" = "%{0to3Hours}",
+    "[lbf_av]" = "[lbf_av]",
+    "H/wk" = "h/wk",
+    "/10*12{RBCs}" = "/10*12{RBCs}",
+    "/h" = "/h",
+    "%{Hemolysis}" = "%{Hemolysis}",
+    "/kg" = "/kg",
+    "U/g{Hb}" = "U/g{Hb}",
+    "[MPL'U]" = "[MPL'U]",
+    "Mmol/mol{creat}" = "mmol/mol{creat}",
+    "Mg/g{wet_tissue}" = "mg/g{wet_tissue}",
+    "Umol/L{RBCs}" = "umol/L{RBCs}",
+    Rad = "rad",
+    Ueq = "ueq",
+    "Ohm.m" = "Ohm.m",
+    "{OpticalDensityIndex}" = "{OpticalDensityIndex}",
+    "Ng/(kg.h)" = "ng/(kg.h)",
+    "Mmol/kg/min" = "mmol/kg/min",
+    "Num10.L/(min.m2)" = "10.L/(min.m2)",
+    "%{BasalActivity}" = "%{BasalActivity}",
+    "[APL'U]" = "[APL'U]",
+    "[Btu_39]" = "[Btu_39]",
+    "Ng/mg" = "ng/mg",
+    "B[W]" = "B[W]",
+    DL = "dL",
+    "{CGG_repeats}" = "{CGG_repeats}",
+    "U/kg{Hb}" = "U/kg{Hb}",
+    "Mg/(kg.h)" = "mg/(kg.h)",
+    "Num10*9/mL" = "10*9/mL",
+    Nm = "nm",
+    "Ng/L" = "ng/L",
+    "{mutation}" = "{mutation}",
+    EV = "eV",
+    "[drp]/[HPF]" = "[drp]/[HPF]",
+    "%{response}" = "%{response}",
+    "/min" = "/min",
+    "/[LPF]" = "/[LPF]",
+    "[pca]" = "[pca]",
+    "[pk_us]" = "[pk_us]",
+    "{ComplementCH50'U}" = "{ComplementCH50'U}",
+    "Num10*6.[IU]" = "10*6.[IU]",
+    "M/s2" = "m/s2",
+    "{cells}/uL" = "{cells}/uL",
+    "%{WBCs}" = "%{WBCs}",
+    "Meq/g" = "meq/g",
+    "{3 times}/d" = "{3 times}/d",
+    "{GPortionPhospholipids}" = "{G-PortionPhospholipids}",
+    Umol = "umol",
+    "Fmol/L" = "fmol/L",
+    "Umol/mol{creat}" = "umol/mol{creat}",
+    "{Volume}/{Vvolume}" = "{Volume}/{Vvolume}",
+    Wb = "Wb",
+    "Nmol/min/mg{Hb}" = "nmol/min/mg{Hb}",
+    "{ARU}" = "{ARU}",
+    "ML/{beat}" = "mL/{beat}",
+    "{Dose}" = "{Dose}",
+    Ukat = "ukat",
+    Mm3 = "mm3",
+    "{Dalton}" = "{Dalton}",
+    L = "L",
+    "U/g{Cre}" = "U/g{Cre}",
+    "{#}" = "{#}",
+    mv = "mV",
+    "%{binding}" = "%{binding}",
+    "Nmol/mg{prot}/h" = "nmol/mg{prot}/h",
+    Mg = "mg",
+    "%{pooled_plasma}" = "%{pooled_plasma}",
+    "{OpticalDensity}" = "{OpticalDensity}",
+    "Ug/{TotalVolume}" = "ug/{TotalVolume}",
+    "%{NormalControl}" = "%{NormalControl}",
+    "{Log}" = "{Log}",
+    "[m_p]" = "[m_p]",
+    "%/100{WBC}" = "%/100{WBC}",
+    "Mg/{Specimen}" = "mg/{Specimen}",
+    "Kcal/kg/(24.h)" = "kcal/kg/(24.h)",
+    "Ug/mg{Cre}" = "ug/mg{Cre}",
+    "[LPF]" = "[LPF]",
+    M2 = "m2",
+    Num1 = "1",
+    Bit = "bit",
+    "{CPM}" = "{CPM}",
+    "Num10*6/L" = "10*6/L",
+    "Ug/g{DryWeight}" = "ug/g{DryWeight}",
+    "[hp_M]" = "[hp_M]",
+    "/10*6" = "/10*6",
+    "Ng{FEU}/mL" = "ng{FEU}/mL",
+    "{Package}" = "{Package}",
+    "Ueq/mL" = "ueq/mL",
+    "Mg/mmol{creat}" = "mg/mmol{creat}",
+    "Umol/g{creat}" = "umol/g{creat}",
+    "Mol/m3" = "mol/m3",
+    "MU/g{Hgb}" = "mU/g{Hgb}",
+    "Nmol/mmol{creat}" = "nmol/mmol{creat}",
+    "%{loss_AChR}" = "%{loss_AChR}",
+    "Umol/min/L" = "umol/min/L",
+    "Mol/L" = "mol/L",
+    Ky = "Ky",
+    "{Molecule}/{Platelet}" = "{Molecule}/{Platelet}",
+    "Mmol/dL" = "mmol/dL",
+    "Num10*3/L" = "10*3/L",
+    "Pg/mg{creat}" = "pg/mg{creat}",
+    "Meq/L" = "meq/L",
+    "%{hemolysis}" = "%{hemolysis}",
+    "G/(8.h){shift}" = "g/(8.h){shift}",
+    "[lk_br]" = "[lk_br]",
+    "L/s" = "L/s",
+    "L/min" = "L/min",
+    "U/g{creat}" = "U/g{creat}",
+    Mx = "Mx",
+    "%{Negative Control}" = "%{Negative Control}",
+    "NU/{RBC}" = "nU/{RBC}",
+    Erg = "erg",
+    "L/h" = "L/h",
+    "%{TotalProtein}" = "%{TotalProtein}",
+    "K[IU]/L" = "k[IU]/L",
+    "Mg/{Tot'Volume}" = "mg/{Tot'Volume}",
+    "%{abnormal}" = "%{abnormal}",
+    "[in_i'H2O]" = "[in_i'H2O]",
+    Ms = "Ms",
+    "{Tscore}" = "{Tscore}",
+    "Mmol/mol{Cre}" = "mmol/mol{Cre}",
+    "KU/h" = "kU/h",
+    "A/m" = "A/m",
+    "Ug/g{Cre}" = "ug/g{Cre}",
+    "[dr_ap]" = "[dr_ap]",
+    "{HaTiter}" = "{HaTiter}",
+    Kat = "kat",
+    "{copies}/mL" = "{copies}/mL",
+    "ML/min" = "mL/min",
+    "ML/(12.h)" = "mL/(12.h)",
+    "[hnsf'U]" = "[hnsf'U]",
+    "Num10*6/{Specimen}" = "10*6/{Specimen}",
+    "Ng/mg{protein}" = "ng/mg{protein}",
+    "/[iU]" = "/[iU]",
+    Hz = "Hz",
+    "{FIU}" = "{FIU}",
+    "[yd_br]" = "[yd_br]",
+    "{FluorescenceIntensity'U}" = "{FluorescenceIntensity'U}",
+    "{Rubella_virus}" = "{Rubella_virus}",
+    "{P2Y12 Reaction Units}" = "{P2Y12 Reaction Units}",
+    "%{Hemoglobin}" = "%{Hemoglobin}",
+    "[drp]/mL" = "[drp]/mL",
+    "[cyd_i]" = "[cyd_i]",
+    "[fur_us]" = "[fur_us]",
+    FL = "fL",
+    "ML/(4.h)" = "mL/(4.h)",
+    "{# of donor informative markers}" = "{# of donor informative markers}",
+    KV = "kV",
+    "Mg/m3" = "mg/m3",
+    "[pt_us]" = "[pt_us]",
+    "Ueq/L" = "ueq/L",
+    "%{ofAvailable}" = "%{ofAvailable}",
+    "{phenotype}" = "{phenotype}",
+    "[pc_br]" = "[pc_br]",
+    "G/mL" = "g/mL",
+    "[D'ag'U]" = "[D'ag'U]",
+    G = "G",
+    "Mg/kg/(8.h)" = "mg/kg/(8.h)",
+    "[HPF]" = "[HPF]",
+    Ps = "ps",
+    "L/s/s2" = "L/s/s2",
+    "Num10*6.eq/mL" = "10*6.eq/mL",
+    KBq = "kBq",
+    "Mg/d/{1.73_m2}" = "mg/d/{1.73_m2}",
+    "[AU]" = "[AU]",
+    Ao = "Ao",
+    "[drp]/h" = "[drp]/h",
+    "ML/(8.h)/kg" = "mL/(8.h)/kg",
+    "Mg/mg{creat}" = "mg/mg{creat}",
+    "Ug/L/(24.h)" = "ug/L/(24.h)",
+    "ML/mm" = "mL/mm",
+    "Nmol/L{RBCs}" = "nmol/L{RBCs}",
+    "[car_Au]" = "[car_Au]",
+    Dg = "dg",
+    Sr = "sr",
+    "%{normal}" = "%{normal}",
+    "/{oif}" = "/{oif}",
+    "{ElisaValue}" = "{ElisaValue}",
+    "Nmol{BCE}/mmol{creat}" = "nmol{BCE}/mmol{creat}",
+    "Mg/d" = "mg/d",
+    "[Btu_th]" = "[Btu_th]",
+    "[iU]/mL" = "[iU]/mL",
+    "{IndexValue}" = "{IndexValue}",
+    "[GPL'U]/mL" = "[GPL'U]/mL",
+    "{Ct}" = "{Ct}",
+    "{IFA_titer}" = "{IFA_titer}",
+    "Mg/{total_output}" = "mg/{total_output}",
+    "%{lysis}" = "%{lysis}",
+    "Mg/mg" = "mg/mg",
+    "{JuvenileDiabetesFound'U}" = "{JuvenileDiabetesFound'U}",
+    "{Each}" = "{Each}",
+    "[fth_br]" = "[fth_br]",
+    "MU/mmol{RBCs}" = "mU/mmol{RBCs}",
+    "{log_IU}/mL" = "{log_IU}/mL",
+    "Nmol/g{Cre}" = "nmol/g{Cre}",
+    "{Copies}/mL" = "{Copies}/mL",
+    "Cal_[15]" = "cal_[15]",
+    DB = "dB",
+    "[lb_tr]" = "[lb_tr]",
+    "L/d" = "L/d",
+    "[Btu_m]" = "[Btu_m]",
+    J = "J",
+    "MPa.s" = "mPa.s",
+    "[iU]" = "[iU]",
+    "Mmol/kg{H2O}" = "mmol/kg{H2O}",
+    "Mbar/L/s" = "mbar/L/s",
+    "{RubellaVirus}" = "{RubellaVirus}",
+    "Nmol/m/mg{protein}" = "nmol/m/mg{protein}",
+    "Pg/{cell}" = "pg/{cell}",
+    "Mg/wk" = "mg/wk",
+    "Mmol/g{hemoglobin}" = "mmol/g{hemoglobin}",
+    "[IU]/(2.h)" = "[IU]/(2.h)",
+    "{EIATiter}" = "{EIATiter}",
+    "{ISR}" = "{ISR}",
+    "Ng/mL{RBCs}" = "ng/mL{RBCs}",
+    "G/(48.h)" = "g/(48.h)",
+    "G/mg" = "g/mg",
+    "FL/nL" = "fL/nL",
+    "Nmol/g" = "nmol/g",
+    "[mu_0]" = "[mu_0]",
+    "/(12.h)" = "/(12.h)",
+    "[pi].rad/min" = "[pi].rad/min",
+    "Ug/kg" = "ug/kg",
+    "Pmol/min" = "pmol/min",
+    "[IU]/min" = "[IU]/min",
+    Ks = "ks",
+    "Mmol/m" = "mmol/m",
+    Ns = "ns",
+    "Kg{wet'tis}" = "kg{wet'tis}",
+    "Kg/h" = "kg/h",
+    "%{Blockade}" = "%{Blockade}",
+    "{minidrop}/s" = "{minidrop}/s",
+    "G/kg/d" = "g/kg/d",
+    "{KRONU'U}/mL" = "{KRONU'U}/mL",
+    "Mmol/{TotalVolume}" = "mmol/{TotalVolume}",
+    Mo = "mo",
+    "Mmol/(6.h)" = "mmol/(6.h)",
+    "{CAG_repeats}" = "{CAG_repeats}",
+    "J/L" = "J/L",
+    "{IgAAntiphosphatidyleserine'U}" = "{IgAAntiphosphatidyleserine'U}",
+    "[BAU]" = "[BAU]",
+    M = "m",
+    "Meq/(12.h)" = "meq/(12.h)",
+    Gal = "Gal",
+    "[fdr_br]" = "[fdr_br]",
+    "{CPM}/10*3{cell}" = "{CPM}/10*3{cell}",
+    "Nmol/mg{creat}" = "nmol/mg{creat}",
+    "Ug/h" = "ug/h",
+    "{GAA_repeats}" = "{GAA_repeats}",
+    "Ug/g{tissue}" = "ug/g{tissue}",
+    "[lk_us]" = "[lk_us]",
+    "Num10.uN.s/(cm5.m2)" = "10.uN.s/(cm5.m2)",
+    "Ug/{Specimen}" = "ug/{Specimen}",
+    "Mmol/kg/d" = "mmol/kg/d",
+    "{Bead}" = "{Bead}",
+    "G/{total_output}" = "g/{total_output}",
+    "KU/g" = "kU/g",
+    PT = "pT",
+    "/{tot}" = "/{tot}",
+    "Nmol/min/10*6{cells}" = "nmol/min/10*6{cells}",
+    "Kg/(s.m2)" = "kg/(s.m2)",
+    "{cfu}" = "{cfu}",
+    "ML/(kg.min)" = "mL/(kg.min)",
+    "ML/{h'b}" = "mL/{h'b}",
+    "[pi]" = "[pi]",
+    Oe = "Oe",
+    "UL/(2.h)" = "uL/(2.h)",
+    "UU/g" = "uU/g",
+    St = "St",
+    "/g{wet'tis}" = "/g{wet'tis}",
+    "{risk}" = "{risk}",
+    "{INR}" = "{INR}",
+    "Mg/mL" = "mg/mL",
+    "ML/(6.h)" = "mL/(6.h)",
+    "{count}" = "{count}",
+    "[acr_us]" = "[acr_us]",
+    "Ng/mg{prot}" = "ng/mg{prot}",
+    "Num10*6/uL" = "10*6/uL",
+    "{#}/d" = "{#}/d",
+    "{LymeIndexValue}" = "{LymeIndexValue}",
+    Mho = "mho",
+    "{index}" = "{index}",
+    "U/g{protein}" = "U/g{protein}",
+    "{#}/wk" = "{#}/wk",
+    "Umol/m" = "umol/m",
+    Sv = "Sv",
+    "[lb_av]" = "[lb_av]",
+    "Mol/mol{creat}" = "mol/mol{creat}",
+    "[lcwt_av]" = "[lcwt_av]",
+    "/g{tot_prot}" = "/g{tot_prot}",
+    "Ug/kg/d" = "ug/kg/d",
+    "{KRONU'U}/L" = "{KRONU'U}/L",
+    "[iU]/dL" = "[iU]/dL",
+    S = "S",
+    "{IgGAntiphosphatidyleserine'U}" = "{IgGAntiphosphatidyleserine'U}",
+    "Ug/g{hair}" = "ug/g{hair}",
+    "%{baseline}" = "%{baseline}",
+    "{EIA'U}/U" = "{EIA'U}/U",
+    "Umol/g{Cre}" = "umol/g{Cre}",
+    "L.s2/s" = "L.s2/s",
+    "[kn_i]" = "[kn_i]",
+    "G{creat}" = "g{creat}",
+    "[Btu_IT]" = "[Btu_IT]",
+    "Mg{creat}" = "mg{creat}",
+    "Ng/min" = "ng/min",
+    "Ug/mmol{creat}" = "ug/mmol{creat}",
+    "[min_br]" = "[min_br]",
+    "%{SpermMotility}" = "%{SpermMotility}",
+    "[in_i]" = "[in_i]",
+    "{Log_IU}/mL" = "{Log_IU}/mL",
+    "{Ehrlich'U}/100.g" = "{Ehrlich'U}/100.g",
+    "[drp]" = "[drp]",
+    "{Vial}" = "{Vial}",
+    "Mg/dL" = "mg/dL",
+    "Cm[H2O]/L/s" = "cm[H2O]/L/s",
+    "Nmol/umol{creat}" = "nmol/umol{creat}",
+    "{INR'unit}" = "{INR'unit}",
+    "[car_m]" = "[car_m]",
+    "/g{Hb}" = "/g{Hb}",
+    "{#}/min" = "{#}/min",
+    "U/umol" = "U/umol",
+    "{IgGIndex}" = "{IgGIndex}",
+    "ML/(5.h)" = "mL/(5.h)",
+    "{Pill}" = "{Pill}",
+    "[CFU]" = "[CFU]",
+    "{Cans}/wk" = "{Cans}/wk",
+    "[nmi_br]" = "[nmi_br]",
+    "Lm.m2" = "lm.m2",
+    "[nmi_i]" = "[nmi_i]",
+    H = "H",
+    "G/(8.h)" = "g/(8.h)",
+    "/m3" = "/m3",
+    "M2/s" = "m2/s",
+    Deg = "deg",
+    "Mg/(6.h)" = "mg/(6.h)",
+    "[gal_us]" = "[gal_us]",
+    "Cm[Hg]" = "cm[Hg]",
+    "ML/(2.h)" = "mL/(2.h)",
+    "/{Specimen}" = "/{Specimen}",
+    "Nmol/mg{protein}/h" = "nmol/mg{protein}/h",
+    "{CfTiter}" = "{CfTiter}",
+    "Meq/{total_volume}" = "meq/{total_volume}",
+    Mosm = "mosm",
+    "[PNU]" = "[PNU]",
+    Km = "km",
+    "Num10.uN.s/cm2" = "10.uN.s/cm2",
+    "[rd_br]" = "[rd_br]",
+    "%{OfWBCs}" = "%{OfWBCs}",
+    "%{Positive}" = "%{Positive}",
+    "{RecTiter}" = "{RecTiter}",
+    "/10*12{rbc}" = "/10*12{rbc}",
+    "Ug/mg{creat}" = "ug/mg{creat}",
+    "ML/mbar" = "mL/mbar",
+    "U/10" = "U/10",
+    "M[iU]" = "m[iU]",
+    "Umol/kg" = "umol/kg",
+    "H/d" = "h/d",
+    "{Can}" = "{Can}",
+    "Cm2/s" = "cm2/s",
+    "Dyn.s/cm" = "dyn.s/cm",
+    "{Ehrlich'U}/(2.h)" = "{Ehrlich'U}/(2.h)",
+    "Min/wk" = "min/wk",
+    "G/kg/(8.h)" = "g/kg/(8.h)",
+    "/mg" = "/mg",
+    "ML/s" = "mL/s",
+    "%{saturation}" = "%{saturation}",
+    Ph = "ph",
+    "L/kg" = "L/kg",
+    KU = "kU",
+    "{delta_OD}" = "{delta_OD}",
+    Um = "um",
+    "Um/s" = "um/s",
+    "[drp]/min" = "[drp]/min",
+    PA = "pA",
+    "[iU]/L" = "[iU]/L",
+    "[syd_i]" = "[syd_i]",
+    "Umol/mg" = "umol/mg",
+    "%{Uptake}" = "%{Uptake}",
+    "Ug/g" = "ug/g",
+    "{5 times}/d" = "{5 times}/d",
+    "MU/g{Hb}" = "mU/g{Hb}",
+    "Mg/h" = "mg/h",
+    "Num10.L/min" = "10.L/min",
+    "[tbs_us]" = "[tbs_us]",
+    "/mm3" = "/mm3",
+    "A_g" = "a_g",
+    "Umol/g{Hgb}" = "umol/g{Hgb}",
+    "G/g{tissue}" = "g/g{tissue}",
+    "%{total}" = "%{total}",
+    "{score}" = "{score}",
+    "G/mmol" = "g/mmol",
+    "[IU]/L" = "[IU]/L",
+    "Eq/L" = "eq/L",
+    "Meq/(8.h.kg)" = "meq/(8.h.kg)",
+    "Pmol/mL" = "pmol/mL",
+    "ML/kg/min" = "mL/kg/min",
+    "M/s" = "m/s",
+    "Pmol/mmol{creat}" = "pmol/mmol{creat}",
+    "Mo_s" = "mo_s",
+    "%" = "%",
+    Sph = "sph",
+    "G.m/{H.B.}" = "g.m/{H.B.}",
+    Kcal = "kcal",
+    "Mg/m2" = "mg/m2",
+    "{TSI_index}" = "{TSI_index}",
+    "[cup_us]" = "[cup_us]",
+    "N.cm" = "N.cm",
+    "U/10*12" = "U/10*12",
+    "{dilution}" = "{dilution}",
+    "Ug/mL" = "ug/mL",
+    "Mol/kg/s" = "mol/kg/s",
+    "Mg/{total_volume}" = "mg/{total_volume}",
+    "[Ch]" = "[Ch]",
+    "ML/{beat}/m2" = "mL/{beat}/m2",
+    "[IU]" = "[IU]",
+    "{Beats}/min" = "{Beats}/min",
+    "Umol/h" = "umol/h",
+    "{Times}/wk" = "{Times}/wk",
+    "Mm[H2O]" = "mm[H2O]",
+    "Fmol/mg{cytosol_protein}" = "fmol/mg{cytosol_protein}",
+    "%{bound}" = "%{bound}",
+    "[yd_i]" = "[yd_i]",
+    "Mg/kg/min" = "mg/kg/min",
+    R = "R",
+    "{Scoop}" = "{Scoop}",
+    "Ug/g{dry_wt}" = "ug/g{dry_wt}",
+    "{Tine'U}" = "{Tine'U}",
+    "{Elisa_U}/mL" = "{Elisa_U}/mL",
+    UCi = "uCi",
+    "U/mL{RBC}" = "U/mL{RBC}",
+    "[ft_us]" = "[ft_us]",
+    "[bu_br]" = "[bu_br]",
+    "[in_i'Hg]" = "[in_i'Hg]",
+    "Mg/{Hgb}/g" = "mg/{Hgb}/g",
+    "[dqt_us]" = "[dqt_us]",
+    C = "C",
+    "Mg{FEU}/L" = "mg{FEU}/L",
+    "Num10*3.{RBC}" = "10*3.{RBC}",
+    "B[uV]" = "B[uV]",
+    "[m_e]" = "[m_e]",
+    "{#}/a" = "{#}/a",
+    "Mmol/h/mg{prot}" = "mmol/h/mg{prot}",
+    ms = "ms",
+    "{breaths}/min" = "{breaths}/min",
+    "Eq/umol" = "eq/umol",
+    Wk = "wk",
+    "Meq/{Specimen}" = "meq/{Specimen}",
+    "Mmol/{total_vol}" = "mmol/{total_vol}",
+    "%{viable}" = "%{viable}",
+    "Umol/min" = "umol/min",
+    "Num24.h" = "24.h",
+    "[dpt_us]" = "[dpt_us]",
+    "Mmol/mol" = "mmol/mol",
+    "{GPS'U}" = "{GPS'U}",
+    "Meq/m2" = "meq/m2",
+    "U/(1.h)" = "U/(1.h)",
+    "/L" = "/L",
+    "/[arb'U]" = "/[arb'U]",
+    "[eps_0]" = "[eps_0]",
+    "U[IU]/mL" = "u[IU]/mL",
+    "Kcal/[oz_av]" = "kcal/[oz_av]",
+    F = "F",
+    "[ft_us]/[ft_us]" = "[ft_us]/[ft_us]",
+    "/dL" = "/dL",
+    "{STDV}" = "{STDV}",
+    "{ELISA'U}" = "{ELISA'U}",
+    "Cal_th" = "cal_th",
+    "G/d" = "g/d",
+    "U/10*9" = "U/10*9",
+    "MU/mg{Cre}" = "mU/mg{Cre}",
+    Circ = "circ",
+    "Nmol/h/mg{prot}" = "nmol/h/mg{prot}",
+    "[ft_br]" = "[ft_br]",
+    "M[H2O]" = "m[H2O]",
+    "%{Binding}" = "%{Binding}",
+    "/{Entity}" = "/{Entity}",
+    "{HA_titer}" = "{HA_titer}",
+    "G/(72.h)" = "g/(72.h)",
+    "[IU]/mg{creat}" = "[IU]/mg{creat}",
+    "L/(8.h)" = "L/(8.h)",
+    "/uL" = "/uL",
+    "UL/h" = "uL/h",
+    Pkat = "pkat",
+    "{percentile}" = "{percentile}",
+    "Pmol/(24.h)" = "pmol/(24.h)",
+    "Umol/d" = "umol/d",
+    "Mo_g" = "mo_g",
+    "Pmol/L" = "pmol/L",
+    "ML/min/(173.10*Num2.m2)" = "mL/min/(173.10*-2.m2)",
+    "[mil_us]" = "[mil_us]",
+    "{index_val}" = "{index_val}",
+    "{JDF'U}/L" = "{JDF'U}/L",
+    "UU/L" = "uU/L",
+    "[srd_us]" = "[srd_us]",
+    "Mg/kg/h" = "mg/kg/h",
+    "Num10*6/kg" = "10*6/kg",
+    "Mmol/{Tot'Volume}" = "mmol/{Tot'Volume}",
+    "Nmol/h/L" = "nmol/h/L",
+    "[IU]/g" = "[IU]/g",
+    "{Number}" = "{Number}",
+    "Kcal/(8.h)" = "kcal/(8.h)",
+    "MV/s" = "mV/s",
+    "%{residual}" = "%{residual}",
+    "Osm/kg" = "osm/kg",
+    "{KCT'U}" = "{KCT'U}",
+    "{ComplementCH100'U}" = "{ComplementCH100'U}",
+    "{minidrp}" = "{minidrp}",
+    "/10*10" = "/10*10",
+    "Nmol/min/mL" = "nmol/min/mL",
+    "Ng/U" = "ng/U",
+    B = "B",
+    "{IgMAntiphosphatidyleserine'U}" = "{IgMAntiphosphatidyleserine'U}",
+    "%{HumanResponse}" = "%{HumanResponse}",
+    "G/{TotalWeight}" = "g/{TotalWeight}",
+    "%{recovery}" = "%{recovery}",
+    "Nmol/s" = "nmol/s",
+    "MU/mmol{creatinine}" = "mU/mmol{creatinine}",
+    "/g{HGB}" = "/g{HGB}",
+    "U/10*10{cells}" = "U/10*10{cells}",
+    "{Streptozyme'U}" = "{Streptozyme'U}",
+    "%{penetration}" = "%{penetration}",
+    "/cm[H2O]" = "/cm[H2O]",
+    "Nmol/d" = "nmol/d",
+    "{IfaIndex}" = "{IfaIndex}",
+    "G{total_nit}" = "g{total_nit}",
+    "{Cells}/uL" = "{Cells}/uL",
+    a = "a",
+    "U/dL" = "U/dL",
+    "G/kg/(8.h){shift}" = "g/kg/(8.h){shift}",
+    "[IU]/kg/d" = "[IU]/kg/d",
+    "Ug/g{feces}" = "ug/g{feces}",
+    "{Count}" = "{Count}",
+    "Mmol/s/L" = "mmol/s/L",
+    "Num10*8" = "10*8",
+    "{Pan_Bio'U}" = "{Pan_Bio'U}",
+    "[didot]" = "[didot]",
+    "[bu_us]" = "[bu_us]",
+    "Ag/{cell}" = "ag/{cell}",
+    Cal = "cal",
+    "%{Abnormal}" = "%{Abnormal}",
+    "[qt_us]" = "[qt_us]",
+    "ML/dL" = "mL/dL",
+    "{#}/g" = "{#}/g",
+    "[diop]" = "[diop]",
+    "[PFU]" = "[PFU]",
+    "{copies}/ug" = "{copies}/ug",
+    "Kg/L" = "kg/L",
+    Torr = "Torr",
+    "Ug/mL{FEU}" = "ug/mL{FEU}",
+    "[IU]/d" = "[IU]/d",
+    "[dye'U]" = "[dye'U]",
+    "Eq/mL" = "eq/mL",
+    "Pmol/dL" = "pmol/dL",
+    Bd = "Bd",
+    "MU/g" = "mU/g",
+    "[hd_i]" = "[hd_i]",
+    "{mm/dd/yyyy}" = "{mm/dd/yyyy}",
+    "[pk_br]" = "[pk_br]",
+    "{# of informative markers}" = "{# of informative markers}",
+    Fg = "fg",
+    "Ug/kg/(8.h)" = "ug/kg/(8.h)",
+    MA = "mA",
+    "Umol/mg{Cre}" = "umol/mg{Cre}",
+    "Nmol{1/2cys}/mg{protein}" = "nmol{1/2cys}/mg{protein}",
+    "/10*12" = "/10*12",
+    "MU/g{protein}" = "mU/g{protein}",
+    "Mg/dL{RBCs}" = "mg/dL{RBCs}",
+    "[twp]" = "[twp]",
+    "[TCID_50]" = "[TCID_50]",
+    "[lb_ap]" = "[lb_ap]",
+    "{2 or 3 times}/d" = "{2 or 3 times}/d",
+    Osm = "osm",
+    "G/(3.d)" = "g/(3.d)",
+    "/100{WBCs}" = "/100{WBCs}",
+    "Umol/umol{creat}" = "umol/umol{creat}",
+    Cm2 = "cm2",
+    "U/mmol{creat}" = "U/mmol{creat}",
+    "G/(100.g)" = "g/(100.g)",
+    "Umol/(2.h)" = "umol/(2.h)",
+    "G/kg/min" = "g/kg/min",
+    "Nm/s/L" = "nm/s/L",
+    "Ng/h" = "ng/h",
+    "G/g{creat}" = "g/g{creat}",
+    "{EIA'U}" = "{EIA'U}",
+    "{Markers}" = "{Markers}",
+    "{Drinks}/d" = "{Drinks}/d",
+    "{Log_IU}" = "{Log_IU}",
+    "{CH100'U}" = "{CH100'U}",
+    "ML/({h'b}.m2)" = "mL/({h'b}.m2)",
+    "[iU]/g" = "[iU]/g",
+    "L/(24.h)" = "L/(24.h)",
+    "G/cm2" = "g/cm2",
+    "Ug/g{dry_tissue}" = "ug/g{dry_tissue}",
+    "Nmol/mg" = "nmol/mg",
+    "[drp]/s" = "[drp]/s",
+    "%{OfLymphocytes}" = "%{OfLymphocytes}",
+    "{copies}" = "{copies}",
+    "U/kg/h" = "U/kg/h",
+    UL = "uL",
+    "[mi_br]" = "[mi_br]",
+    "{clock_time}" = "{clock_time}",
+    "'" = "'",
+    "/m2" = "/m2",
+    "%{Carboxyhemoglobin}" = "%{Carboxyhemoglobin}",
+    "[hp_Q]" = "[hp_Q]",
+    "[c]" = "[c]",
+    "G.m/({hb}.m2)" = "g.m/({hb}.m2)",
+    "[mi_us]" = "[mi_us]",
+    "{RadioactiveT3UptakeRatio}" = "{RadioactiveT3UptakeRatio}",
+    "Umol/g{Hb}" = "umol/g{Hb}",
+    P = "P",
+    CP = "cP",
+    "[CCID_50]" = "[CCID_50]",
+    "{IfaTiter}" = "{IfaTiter}",
+    "[Amb'a'1'U]" = "[Amb'a'1'U]",
+    "Mg{Phenylketones}/dL" = "mg{Phenylketones}/dL",
+    "[gil_us]" = "[gil_us]",
+    "{ImmuneStatusRatio}" = "{ImmuneStatusRatio}",
+    "Umol/L{rbc}" = "umol/L{rbc}",
+    "[ly]" = "[ly]",
+    "Mmol/(12.h)" = "mmol/(12.h)",
+    "Meq/mL" = "meq/mL",
+    "[MPL'U]/mL" = "[MPL'U]/mL",
+    "Mmol/d" = "mmol/d",
+    "Meq/{specimen}" = "meq/{specimen}",
+    "[oz_tr]" = "[oz_tr]",
+    UV = "uV",
+    "[k]" = "[k]",
+    "Pg/mL{sLT}" = "pg/mL{sLT}",
+    "{DdTiter}" = "{DdTiter}",
+    "%{Index}" = "%{Index}",
+    "Nmol/min/mg{protein}" = "nmol/min/mg{protein}",
+    "{TmStp}" = "{TmStp}",
+    "DaL/min/m2" = "daL/min/m2",
+    "/g{creat}" = "/g{creat}",
+    "[rlk_us]" = "[rlk_us]",
+    "Ug/(100.g)" = "ug/(100.g)",
+    KL = "kL",
+    "{log_copies}/mL" = "{log_copies}/mL",
+    "Num10*6.[iU]" = "10*6.[iU]",
+    t = "t",
+    "Mg/{collection}" = "mg/{collection}",
+    Eq = "eq",
+    "U/s" = "U/s",
+    "G/(5.h)" = "g/(5.h)",
+    Us = "us",
+    "Mmol/L/s" = "mmol/L/s",
+    "Mg/{Volume}" = "mg/{Volume}",
+    "Mmol/(8.h.kg)" = "mmol/(8.h.kg)",
+    "Num10*3{RBCs}" = "10*3{RBCs}",
+    "M[Hg]" = "m[Hg]",
+    "NU/mL" = "nU/mL",
+    "[rch_us]" = "[rch_us]",
+    "Kcal/d" = "kcal/d",
+    "%{HemoglobinSaturation}" = "%{HemoglobinSaturation}",
+    "{Elisa'U}/mL" = "{Elisa'U}/mL",
+    "/wk" = "/wk",
+    "Cm/s" = "cm/s",
+    "[pnt_pr]" = "[pnt_pr]",
+    "G/(4.h)" = "g/(4.h)",
+    "{RBC}/uL" = "{RBC}/uL",
+    "[CFU]/mL" = "[CFU]/mL",
+    V = "V",
+    U = "U",
+    "MU/mmol{creat}" = "mU/mmol{creat}",
+    "Mg/{specimen}" = "mg/{specimen}",
+    "Num10.uN.s/cm" = "10.uN.s/cm",
+    "{ThyroxinUptake'U}" = "{ThyroxinUptake'U}",
+    Ohm = "Ohm",
+    "Eq/mmol" = "eq/mmol",
+    "[bbl_us]" = "[bbl_us]",
+    "D/wk" = "d/wk",
+    "G/g" = "g/g",
+    "{NonspecificOunce}" = "{NonspecificOunce}",
+    "Umol/g{hemoglobin}" = "umol/g{hemoglobin}",
+    "Nmol/mL/h" = "nmol/mL/h",
+    "Umol/10*6{RBC}" = "umol/10*6{RBC}",
+    "%{Cound}" = "%{Cound}",
+    Meq = "meq",
+    "ML{fetal_RBCs}" = "mL{fetal_RBCs}",
+    "[ch_us]" = "[ch_us]",
+    "{OpticalDensityRatio}" = "{OpticalDensityRatio}",
+    "G/cm3" = "g/cm3",
+    "{beats}/min" = "{beats}/min",
+    Bi = "Bi",
+    "[IU]/dL" = "[IU]/dL",
+    "G/h/m2" = "g/h/m2",
+    "Umol/g" = "umol/g",
+    "Mmol/kg" = "mmol/kg",
+    Cm3 = "cm3",
+    "ML/L" = "mL/L",
+    "[mclg'U]" = "[mclg'U]",
+    "Ug/L{RBCs}" = "ug/L{RBCs}",
+    Cd = "cd",
+    "{Ehrlich'U}/d" = "{Ehrlich'U}/d",
+    "[in_br]" = "[in_br]",
+    "{AHF'U}" = "{AHF'U}",
+    "[lton_av]" = "[lton_av]",
+    "[bf_i]" = "[bf_i]",
+    "/10*4{RBCs}" = "/10*4{RBCs}",
+    "Mg/(18.h)" = "mg/(18.h)",
+    "Min/d" = "min/d",
+    "[iU]/kg" = "[iU]/kg",
+    "{PackYears}" = "{PackYears}",
+    "Umol/mol{Cre}" = "umol/mol{Cre}",
+    "Mg/d/(173.10*Num2.m2)" = "mg/d/(173.10*-2.m2)",
+    "[tb'U]" = "[tb'U]",
+    "Dm2/s2" = "dm2/s2",
+    "U/10*10" = "U/10*10",
+    b = "b",
+    "ML/(10.h)" = "mL/(10.h)",
+    "Mmol/g" = "mmol/g",
+    "Ng/m2" = "ng/m2",
+    "Umol/mg{creat}" = "umol/mg{creat}",
+    "/{OIF}" = "/{OIF}",
+    "Nmol/L/s" = "nmol/L/s",
+    "[sft_i]" = "[sft_i]",
+    "/mL" = "/mL",
+    "%{ofBacteria}" = "%{ofBacteria}",
+    "[min_us]" = "[min_us]",
+    "Num10*6" = "10*6",
+    "/mo" = "/mo",
+    "Dyn.s/(cm.m2)" = "dyn.s/(cm.m2)",
+    "/100{WBC}" = "/100{WBC}",
+    "Ug/[sft_i]" = "ug/[sft_i]",
+    "{CGG}" = "{CGG}",
+    "[IU]/g{Hb}" = "[IU]/g{Hb}",
+    "Num10*Num6{Immunofluorescence'U}" = "10*-6{Immunofluorescence'U}",
+    "Ng/10*6{RBCs}" = "ng/10*6{RBCs}",
+    "[acr_br]" = "[acr_br]",
+    "Bit_s" = "bit_s",
+    MPa = "mPa",
+    "{StimulatingIndex}" = "{StimulatingIndex}",
+    "[arb'U]/mL" = "[arb'U]/mL",
+    "[knk'U]" = "[knk'U]",
+    Cel = "Cel",
+    "Pg/mm" = "pg/mm",
+    HL = "hL",
+    "UU/mL" = "uU/mL",
+    "Meq/(24.h)" = "meq/(24.h)",
+    "Mg/(8.h)" = "mg/(8.h)",
+    "{Percentile}" = "{Percentile}",
+    "{EhrlichU}/dL" = "{EhrlichU}/dL",
+    "%{positive}" = "%{positive}",
+    "{Absorbance'U}" = "{Absorbance'U}",
+    "[hp_C]" = "[hp_C]",
+    "G/(kg.min)" = "g/(kg.min)",
+    "{Once}/d" = "{Once}/d",
+    "{IgAPhospholipid'U}" = "{IgAPhospholipid'U}",
+    "{StandardIgM'U}" = "{StandardIgM'U}",
+    "G/(8.kg.h)" = "g/(8.kg.h)",
+    "Meq/kg/min" = "meq/kg/min",
+    "Mmol/h/mg{Hb}" = "mmol/h/mg{Hb}",
+    "K/W" = "K/W",
+    "Mg/(72.h)" = "mg/(72.h)",
+    "[FFU]" = "[FFU]",
+    "[arb'U]" = "[arb'U]",
+    Mbar = "mbar",
+    "U/g{Hgb}" = "U/g{Hgb}",
+    "{minidrop}/min" = "{minidrop}/min",
+    "Meq/g{creat}" = "meq/g{creat}",
+    "{#}/{platelet}" = "{#}/{platelet}",
+    "%{Tot'Hgb}" = "%{Tot'Hgb}",
+    "Ug/mmol" = "ug/mmol",
+    "Nmol/mg/h" = "nmol/mg/h",
+    "[ft_i]" = "[ft_i]",
+    g = "g",
+    "Mmol/g{creat}" = "mmol/g{creat}",
+    "Num10*4/uL" = "10*4/uL",
+    MCi = "mCi",
+    "[arb'U]/L" = "[arb'U]/L",
+    "Mm/min" = "mm/min",
+    "{Capsule}" = "{Capsule}",
+    "{StandardDeviation}" = "{StandardDeviation}",
+    "%{Tot'Cholesterol}" = "%{Tot'Cholesterol}",
+    "{ScoreOf}" = "{ScoreOf}",
+    "%{at_60_min}" = "%{at_60_min}",
+    "Mg/kg" = "mg/kg",
+    "Umol/umol" = "umol/umol",
+    "Meq/d" = "meq/d",
+    "ML/h" = "mL/h",
+    MV = "MV",
+    "Num10*6/mm3" = "10*6/mm3",
+    "Mg/min" = "mg/min",
+    By = "By",
+    "Nmol/min/mg{hemoglobin}" = "nmol/min/mg{hemoglobin}",
+    CL = "cL",
+    "Num10*3.U" = "10*3.U",
+    l = "l",
+    "%{Oxygen}" = "%{Oxygen}",
+    "U/g" = "U/g",
+    "{IgMIndex}" = "{IgMIndex}",
+    "Nmol/nmol" = "nmol/nmol",
+    "ML/kg/(8.h)" = "mL/kg/(8.h)",
+    "[smgy'U]" = "[smgy'U]",
+    "U[IU]" = "u[IU]",
+    "[gr]" = "[gr]",
+    "G/mol{creat}" = "g/mol{creat}",
+    N = "N",
+    "{StdDeviation'U}" = "{StdDeviation'U}",
+    NL = "nL",
+    "Cm[H2O]/s/m" = "cm[H2O]/s/m",
+    "Nmol{BCE}/L" = "nmol{BCE}/L",
+    "/U" = "/U",
+    "Mol/s" = "mol/s",
+    "Nmol/mL/min" = "nmol/mL/min",
+    "Mm/h" = "mm/h",
+    "{s_co_ratio}" = "{s_co_ratio}",
+    "%{Fat}" = "%{Fat}",
+    "{kp_C}" = "{kp_C}",
+    u = "u",
+    "{spray}" = "{spray}",
+    "Mmol/L{RBCs}" = "mmol/L{RBCs}",
+    "[crd_us]" = "[crd_us]",
+    "Cal_[20]" = "cal_[20]",
+    "{lgCopies}/ml" = "{lgCopies}/ml",
+    "/g{tot'prot}" = "/g{tot'prot}",
+    "[GPL'U]" = "[GPL'U]",
+    "Ug/kg/h" = "ug/kg/h",
+    "Mg/(2.h)" = "mg/(2.h)",
+    "{fraction}" = "{fraction}",
+    "/g{tot'nit}" = "/g{tot'nit}",
+    "Nmol/h/mL" = "nmol/h/mL",
+    "{Ct_value}" = "{Ct_value}",
+    "Nmol/L" = "nmol/L",
+    "Kcal/(24.h)" = "kcal/(24.h)",
+    "Meq/min" = "meq/min",
+    "Umol/dL" = "umol/dL",
+    "[IU]/(24.h)" = "[IU]/(24.h)",
+    "[gal_wi]" = "[gal_wi]",
+    "[iU]/g{Hgb}" = "[iU]/g{Hgb}",
+    "Pg/L" = "pg/L",
+    "{molecule}/{platelet}" = "{molecule}/{platelet}",
+    "Umol/min/g{protein}" = "umol/min/g{protein}",
+    "Ug/(24.h)" = "ug/(24.h)",
+    "%{deficient}" = "%{deficient}",
+    A = "A",
+    "Mmol/kg/(8.h)" = "mmol/kg/(8.h)",
+    "[pt_br]" = "[pt_br]",
+    "{clock time}" = "{clock time}",
+    "Ng/g{Cre}" = "ng/g{Cre}",
+    "{OD_unit}" = "{OD_unit}",
+    "{CagRepeat}" = "{CagRepeat}",
+    "%{NormalPooledPlasma}" = "%{NormalPooledPlasma}",
+    "[Btu_59]" = "[Btu_59]",
+    "Mol/d" = "mol/d",
+    "Mg/g" = "mg/g",
+    "Mg/(24.h)" = "mg/(24.h)",
+    Nmol = "nmol",
+    "Nmol/mL" = "nmol/mL",
+    "Ng/(8.h)" = "ng/(8.h)",
+    "Ug/g{creat}" = "ug/g{creat}",
+    "{#}/[HPF]" = "{#}/[HPF]",
+    "Mg/g{Cre}" = "mg/g{Cre}",
+    "%{FetalErythrocytes}" = "%{FetalErythrocytes}",
+    "Nmol/dL{GF}" = "nmol/dL{GF}",
+    "{Absorbance'U}/mL" = "{Absorbance'U}/mL",
+    "{ratio}" = "{ratio}",
+    "Kg.m/s" = "kg.m/s",
+    "{EIAIndex}" = "{EIAIndex}",
+    "/mm" = "/mm",
+    "{tot}" = "{tot}",
+    "Umol/mL/min" = "umol/mL/min",
+    "Nmol/dL" = "nmol/dL",
+    "Pmol/mg{protein}" = "pmol/mg{protein}",
+    "%{EosSeen}" = "%{EosSeen}",
+    "Ng/dL" = "ng/dL",
+    "G/mol" = "g/mol",
+    "Ng/mg{creat}" = "ng/mg{creat}",
+    "/g{hgb}" = "/g{hgb}",
+    Gb = "Gb",
+    "Umol/h/L" = "umol/h/L",
+    "%{normal_pooled_plasma}" = "%{normal_pooled_plasma}",
+    "Nmol/s/L" = "nmol/s/L",
+    "Meq/kg/h" = "meq/kg/h",
+    "Ug/g{Hb}" = "ug/g{Hb}",
+    "/g{tot_nit}" = "/g{tot_nit}",
+    "Umol/min/g" = "umol/min/g",
+    "{EIA_titer}" = "{EIA_titer}",
+    "[kn_br]" = "[kn_br]",
+    "Pmol/d" = "pmol/d",
+    "{tbl}" = "{tbl}",
+    "%{Hb}" = "%{Hb}",
+    "Umol/L/h" = "umol/L/h",
+    "%{loss}" = "%{loss}",
+    "Mol/kg" = "mol/kg",
+    "{Ehrlich_U}/dL" = "{Ehrlich_U}/dL",
+    "G{wet_tissue}" = "g{wet_tissue}",
+    "[sct]" = "[sct]",
+    "Ng/(kg.d)" = "ng/(kg.d)",
+    "{Counts}/min" = "{Counts}/min",
+    "Umol/kg{feces}" = "umol/kg{feces}",
+    "[psi]" = "[psi]",
+    "U/10*12{RBCs}" = "U/10*12{RBCs}",
+    "/mmol" = "/mmol",
+    "{SatIndex}" = "{SatIndex}",
+    "Ug/(8.h)" = "ug/(8.h)",
+    "G/kg/h" = "g/kg/h",
+    "{saturation}" = "{saturation}",
+    "{CAE'U}" = "{CAE'U}",
+    "[stone_av]" = "[stone_av]",
+    "U/mL{RBCs}" = "U/mL{RBCs}",
+    "Num10*9/L" = "10*9/L",
+    "Kcal/h" = "kcal/h",
+    RAD = "RAD",
+    "Mosm/L" = "mosm/L",
+    "Pmol/min/mg{protein}" = "pmol/min/mg{protein}",
+    "Num10*6/mL" = "10*6/mL",
+    "M3/s" = "m3/s",
+    "Meq/h" = "meq/h",
+    "{M.o.M.}" = "{M.o.M.}",
+    "[pnt]" = "[pnt]",
+    "{MultOfMean}" = "{MultOfMean}",
+    "Kat/kg" = "kat/kg",
+    "%{Normal}" = "%{Normal}",
+    "{RPI'U}" = "{RPI'U}",
+    "{APS'U}" = "{APS'U}",
+    "Mmol/{specimen}" = "mmol/{specimen}",
+    "Nmol/mol{creat}" = "nmol/mol{creat}",
+    h = "h",
+    "/mmol{creat}" = "/mmol{creat}",
+    "{StandardIgA'U}" = "{StandardIgA'U}",
+    "{RelativeViscosity}" = "{RelativeViscosity}",
+    "Pg/mg" = "pg/mg",
+    "U/(10.g){feces}" = "U/(10.g){feces}",
+    "Ng/(8.h.kg)" = "ng/(8.h.kg)",
+    Lmb = "Lmb",
+    "Mmol/L" = "mmol/L",
+    "[ppb]" = "[ppb]",
+    "ML/kg/h" = "mL/kg/h",
+    "Pmol/mol" = "pmol/mol",
+    "[CFU]/L" = "[CFU]/L",
+    "[IU]/10*9{RBCs}" = "[IU]/10*9{RBCs}",
+    "Ng/s" = "ng/s",
+    "[h]" = "[h]",
+    "G/(12.h)" = "g/(12.h)",
+    "{Copies}/uL" = "{Copies}/uL",
+    "Fmol/mg{prot}" = "fmol/mg{prot}",
+    "[pptr]" = "[pptr]",
+    "Ug/dL{RBCs}" = "ug/dL{RBCs}",
+    Atm = "atm",
+    "{Cell}" = "{Cell}",
+    "Mg/{TotalVolume}" = "mg/{TotalVolume}",
+    NCi = "nCi",
+    "[bdsk'U]" = "[bdsk'U]",
+    "Ug/min" = "ug/min",
+    "Num1/min" = "1/min",
+    "Ng/g" = "ng/g",
+    "{Patch}" = "{Patch}",
+    "%{Activity}" = "%{Activity}",
+    "[foz_br]" = "[foz_br]",
+    "A_j" = "a_j",
+    "Ng/g{creat}" = "ng/g{creat}",
+    "{#}/L" = "{#}/L",
+    "Ng/mL" = "ng/mL",
+    "ML/m2" = "mL/m2",
+    "[pied]" = "[pied]",
+    "{Immunity}" = "{Immunity}",
+    "Num10*6.[CFU]/L" = "10*6.[CFU]/L",
+    "D/(7.d)" = "d/(7.d)",
+    "{Relative'U}" = "{Relative'U}",
+    "Mmol/m2" = "mmol/m2",
+    "Mg/mg{cre}" = "mg/mg{cre}",
+    "U/(2.h)" = "U/(2.h)",
+    "Ug/d" = "ug/d",
+    "[ppm]{v/v}" = "[ppm]{v/v}",
+    REM = "REM",
+    "Nmol/mmol" = "nmol/mmol",
+    "Nmol{BCE}" = "nmol{BCE}",
+    "[gil_br]" = "[gil_br]",
+    "[Lf]" = "[Lf]",
+    "{shift}" = "{shift}",
+    "/10*3{RBCs}" = "/10*3{RBCs}",
+    "ML/min/{1.73_m2}" = "mL/min/{1.73_m2}",
+    Ar = "ar",
+    "G/(6.h)" = "g/(6.h)",
+    "{MPS'U}/mL" = "{MPS'U}/mL",
+    "G/dL" = "g/dL",
+    "U/(12.h)" = "U/(12.h)",
+    Kg = "kg",
+    "%{blocked}" = "%{blocked}",
+    "Umol/(8.h)" = "umol/(8.h)",
+    "Num10*9/uL" = "10*9/uL",
+    "Mmol/h/mg{protein}" = "mmol/h/mg{protein}",
+    "%{uptake}" = "%{uptake}",
+    "[pca_pr]" = "[pca_pr]",
+    "%{reference}" = "%{reference}",
+    Cg = "cg",
+    "{#}/mL" = "{#}/mL",
+    "{absorbance}" = "{absorbance}",
+    "[sc_ap]" = "[sc_ap]",
+    "ML/min/m2" = "mL/min/m2",
+    "%{Precipitate}" = "%{Precipitate}",
+    "Osm/L" = "osm/L",
+    "Umol/min/g{prot}" = "umol/min/g{prot}",
+    "Ug/m3" = "ug/m3",
+    "{Ehrlich'U}" = "{Ehrlich'U}",
+    "U/L" = "U/L",
+    "/s" = "/s",
+    "[e]" = "[e]",
+    "[fth_i]" = "[fth_i]",
+    "{Globules}/[HPF]" = "{Globules}/[HPF]",
+    "Ng/(24.h)" = "ng/(24.h)",
+    Pc = "pc",
+    "{InhaledTobaccoUseAmountYears}" = "{InhaledTobaccoUseAmountYears}",
+    "Mmol/mmol{urea}" = "mmol/mmol{urea}",
+    Sb = "sb",
+    "%{index}" = "%{index}",
+    Mm = "mm",
+    "Num10*6.U" = "10*6.U",
+    "Pmol/mmol" = "pmol/mmol",
+    "[ch_br]" = "[ch_br]",
+    "DaL/min" = "daL/min",
+    "[MET]" = "[MET]",
+    "{activity}" = "{activity}",
+    "[cml_i]" = "[cml_i]",
+    "Mmol/(8.h)" = "mmol/(8.h)",
+    "{Lyme_index_value}" = "{Lyme_index_value}",
+    "Mmol/{ejaculate}" = "mmol/{ejaculate}",
+    "{Dilution}" = "{Dilution}",
+    "ML/kg/d" = "mL/kg/d",
+    Bar = "bar",
+    W = "W",
+    "G/{specimen}" = "g/{specimen}",
+    "[qt_br]" = "[qt_br]",
+    "Ng/mg/h" = "ng/mg/h",
+    Np = "Np",
+    "N.s" = "N.s",
+    "[mi_i]" = "[mi_i]",
+    "Umol/L" = "umol/L",
+    "U/(18.h)" = "U/(18.h)",
+    "{cells}/[HPF]" = "{cells}/[HPF]",
+    "%{Excretion}" = "%{Excretion}",
+    "[foz_us]" = "[foz_us]",
+    "Nmol/g{creat}" = "nmol/g{creat}",
+    "{StandardIgG'U}" = "{StandardIgG'U}",
+    "[Btu_60]" = "[Btu_60]",
+    "{InhaledTobaccoUsePacks}/d" = "{InhaledTobaccoUsePacks}/d",
+    "G/h" = "g/h",
+    Min = "min",
+    Pg = "pg",
+    "{ElisaIndex}" = "{ElisaIndex}",
+    "%{basal_activity}" = "%{basal_activity}",
+    "G{Hb}" = "g{Hb}",
+    "{Zscore}" = "{Zscore}",
+    "Pg/dL" = "pg/dL",
+    "Cal_IT" = "cal_IT",
+    "%{cells}" = "%{cells}",
+    "G/m2" = "g/m2",
+    "%{Conversion}" = "%{Conversion}",
+    "[cft_i]" = "[cft_i]",
+    "Meq/(8.h)" = "meq/(8.h)",
+    "%{aggregation}" = "%{aggregation}",
+    "L/min/m2" = "L/min/m2",
+    "%{relative}" = "%{relative}",
+    "{Disintegrations}/min" = "{Disintegrations}/min",
+    "[mil_i]" = "[mil_i]",
+    "Ug/L{DDU}" = "ug/L{DDU}",
+    "{ImmuneComplex'U}" = "{ImmuneComplex'U}",
+    "%{Reactivity}" = "%{Reactivity}",
+    "U{G}" = "U{G}",
+    "[yd_us]" = "[yd_us]",
+    "Umol/(24.h)" = "umol/(24.h)",
+    "Ng/kg/min" = "ng/kg/min",
+    "%{activity}" = "%{activity}",
+    "[todd'U]" = "[todd'U]",
+    "Umol/mmol{creat}" = "umol/mmol{creat}",
+    "[HP]" = "[HP]",
+    "{Bowls}/d" = "{Bowls}/d",
+    D = "d",
+    Nkat = "nkat",
+    "[oz_ap]" = "[oz_ap]",
+    "Meq/(2.h)" = "meq/(2.h)",
+    "{#}/uL" = "{#}/uL",
+    "K[iU]/mL" = "k[iU]/mL",
+    "[pouce]" = "[pouce]",
+    "/kg{body_wt}" = "/kg{body_wt}",
+    "[Cal]" = "[Cal]",
+    "Meq/g{Cre}" = "meq/g{Cre}",
+    "%{risk}" = "%{risk}",
+    "[degF]" = "[degF]",
+    "ML/kg" = "mL/kg",
+    "U/h" = "U/h",
+    "G.m" = "g.m",
+    "MU/g{prot}" = "mU/g{prot}",
+    "M[IU]/L" = "m[IU]/L",
+    "{# of calculi}" = "{# of calculi}",
+    "%{dose}" = "%{dose}",
+    "{TIBC'U}" = "{TIBC'U}",
+    "{relative_saturation}" = "{relative_saturation}",
+    "Kg/min" = "kg/min",
+    "MU/L" = "mU/L",
+    "{Ehrlich'U}/dL" = "{Ehrlich'U}/dL",
+    "[cr_i]" = "[cr_i]",
+    "[beth'U]" = "[beth'U]",
+    "{yyyy}" = "{yyyy}",
+    "[hp_X]" = "[hp_X]",
+    "Mmol/(24.h)" = "mmol/(24.h)",
+    "{Spermatozoa}/mL" = "{Spermatozoa}/mL",
+    "Mbar.s/L" = "mbar.s/L",
+    "Ng/mg{Protein}" = "ng/mg{Protein}",
+    "/100{Spermatozoa}" = "/100{Spermatozoa}",
+    "{EV}" = "{EV}",
+    "MU/mL" = "mU/mL",
+    "Mg/(12.h)" = "mg/(12.h)",
+    "[MET].min/wk" = "[MET].min/wk",
+    "{AspirinReaction'U}" = "{AspirinReaction'U}",
+    "Kg/mol" = "kg/mol",
+    "{cfu}/mL" = "{cfu}/mL",
+    "Kg/m3" = "kg/m3",
+    Mm2 = "mm2",
+    "Umol/mol{Hb}" = "umol/mol{Hb}",
+    "ML/cm[H2O]" = "mL/cm[H2O]",
+    "{EIA_index}" = "{EIA_index}",
+    "U/d" = "U/d",
+    Fm = "fm",
+    "Cal_m" = "cal_m",
+    "KU/L" = "kU/L",
+    "S/{control}" = "s/{control}",
+    "Umol{BCE}/mol" = "umol{BCE}/mol",
+    "{GliadinIndexValue}" = "{GliadinIndexValue}",
+    "Ng/(kg.min)" = "ng/(kg.min)",
+    "{Index_val}" = "{Index_val}",
+    "[IU]/mL" = "[IU]/mL",
+    "Ug/kg/min" = "ug/kg/min",
+    "Deg/s" = "deg/s",
+    "U[IU]/L" = "u[IU]/L",
+    "Mmol/mmol{creat}" = "mmol/mmol{creat}",
+    "Umol/min/g{mucosa}" = "umol/min/g{mucosa}",
+    "{DeltaOpticalDensity}" = "{DeltaOpticalDensity}",
+    "{WeeksDays}" = "{WeeksDays}",
+    "[pH]" = "[pH]",
+    Dyn = "dyn",
+    Ng = "ng",
+    "%{RBCs}" = "%{RBCs}",
+    "Ng/kg/(8.h)" = "ng/kg/(8.h)",
+    "[IU]/h" = "[IU]/h",
+    "[mesh_i]" = "[mesh_i]",
+    "[lne]" = "[lne]",
+    "Mg/g{feces}" = "mg/g{feces}",
+    "[dr_av]" = "[dr_av]",
+    "{ActivityCoefficient}" = "{ActivityCoefficient}",
+    "Nmol/mmol{Cre}" = "nmol/mmol{Cre}",
+    "%{excretion}" = "%{excretion}",
+    "L/L" = "L/L",
+    "Num10*3/mL" = "10*3/mL",
+    PL = "pL"
+}
 /** What defines the members of the research element */
 export interface ResearchElementDefinitionCharacteristic extends BackboneElement {
     studyEffectiveTiming?: Timing;
@@ -122,10 +1565,10 @@ export interface ResearchElementDefinitionCharacteristic extends BackboneElement
     _studyEffectiveDescription?: Element;
     definitionCanonical: canonical;
     /** mean | median | mean-of-mean | mean-of-median | median-of-mean | median-of-median */
-    studyEffectiveGroupMeasure?: code;
+    studyEffectiveGroupMeasure?: `${ResearchElementDefinitionStudyEffectiveGroupMeasure}`;
     participantEffectiveTiming?: Timing;
     /** mean | median | mean-of-mean | mean-of-median | median-of-mean | median-of-median */
-    participantEffectiveGroupMeasure?: code;
+    participantEffectiveGroupMeasure?: `${ResearchElementDefinitionParticipantEffectiveGroupMeasure}`;
     /** What time period does the study cover */
     studyEffectiveDescription?: string;
     participantEffectiveDateTime?: dateTime;
@@ -133,7 +1576,7 @@ export interface ResearchElementDefinitionCharacteristic extends BackboneElement
     /** Observation time from study start */
     studyEffectiveTimeFromStart?: Duration;
     /** What unit is the outcome described in? */
-    unitOfMeasure?: CodeableConcept;
+    unitOfMeasure?: `${ResearchElementDefinitionUnitOfMeasure}`;
     participantEffectivePeriod?: Period;
     _participantEffectiveDateTime?: Element;
     /** What time period do participants cover */
@@ -150,3 +1593,10 @@ export interface ResearchElementDefinitionCharacteristic extends BackboneElement
     participantEffectiveTimeFromStart?: Duration;
     studyEffectiveDateTime?: dateTime;
 }
+/** draft | active | retired | unknown */
+export declare enum ResearchElementDefinitionStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ResearchElementDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/ResearchElementDefinition.js
index c8ad2e5..5e36658 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ResearchElementDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ResearchElementDefinition.js
@@ -1,2 +1,1459 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResearchElementDefinitionStatus = exports.ResearchElementDefinitionUnitOfMeasure = exports.ResearchElementDefinitionParticipantEffectiveGroupMeasure = exports.ResearchElementDefinitionStudyEffectiveGroupMeasure = exports.ResearchElementDefinitionType = exports.ResearchElementDefinitionVariableType = void 0;
+/** dichotomous | continuous | descriptive */
+var ResearchElementDefinitionVariableType;
+(function (ResearchElementDefinitionVariableType) {
+    ResearchElementDefinitionVariableType["Continuous"] = "continuous";
+    ResearchElementDefinitionVariableType["Descriptive"] = "descriptive";
+    ResearchElementDefinitionVariableType["Dichotomous"] = "dichotomous";
+})(ResearchElementDefinitionVariableType = exports.ResearchElementDefinitionVariableType || (exports.ResearchElementDefinitionVariableType = {}));
+/** population | exposure | outcome */
+var ResearchElementDefinitionType;
+(function (ResearchElementDefinitionType) {
+    ResearchElementDefinitionType["Exposure"] = "exposure";
+    ResearchElementDefinitionType["Outcome"] = "outcome";
+    ResearchElementDefinitionType["Population"] = "population";
+})(ResearchElementDefinitionType = exports.ResearchElementDefinitionType || (exports.ResearchElementDefinitionType = {}));
+/** mean | median | mean-of-mean | mean-of-median | median-of-mean | median-of-median */
+var ResearchElementDefinitionStudyEffectiveGroupMeasure;
+(function (ResearchElementDefinitionStudyEffectiveGroupMeasure) {
+    ResearchElementDefinitionStudyEffectiveGroupMeasure["Mean"] = "mean";
+    ResearchElementDefinitionStudyEffectiveGroupMeasure["MeanOfMean"] = "mean-of-mean";
+    ResearchElementDefinitionStudyEffectiveGroupMeasure["MeanOfMedian"] = "mean-of-median";
+    ResearchElementDefinitionStudyEffectiveGroupMeasure["Median"] = "median";
+    ResearchElementDefinitionStudyEffectiveGroupMeasure["MedianOfMean"] = "median-of-mean";
+    ResearchElementDefinitionStudyEffectiveGroupMeasure["MedianOfMedian"] = "median-of-median";
+})(ResearchElementDefinitionStudyEffectiveGroupMeasure = exports.ResearchElementDefinitionStudyEffectiveGroupMeasure || (exports.ResearchElementDefinitionStudyEffectiveGroupMeasure = {}));
+/** mean | median | mean-of-mean | mean-of-median | median-of-mean | median-of-median */
+var ResearchElementDefinitionParticipantEffectiveGroupMeasure;
+(function (ResearchElementDefinitionParticipantEffectiveGroupMeasure) {
+    ResearchElementDefinitionParticipantEffectiveGroupMeasure["Mean"] = "mean";
+    ResearchElementDefinitionParticipantEffectiveGroupMeasure["MeanOfMean"] = "mean-of-mean";
+    ResearchElementDefinitionParticipantEffectiveGroupMeasure["MeanOfMedian"] = "mean-of-median";
+    ResearchElementDefinitionParticipantEffectiveGroupMeasure["Median"] = "median";
+    ResearchElementDefinitionParticipantEffectiveGroupMeasure["MedianOfMean"] = "median-of-mean";
+    ResearchElementDefinitionParticipantEffectiveGroupMeasure["MedianOfMedian"] = "median-of-median";
+})(ResearchElementDefinitionParticipantEffectiveGroupMeasure = exports.ResearchElementDefinitionParticipantEffectiveGroupMeasure || (exports.ResearchElementDefinitionParticipantEffectiveGroupMeasure = {}));
+/** What unit is the outcome described in? */
+var ResearchElementDefinitionUnitOfMeasure;
+(function (ResearchElementDefinitionUnitOfMeasure) {
+    ResearchElementDefinitionUnitOfMeasure["Mo_j"] = "mo_j";
+    ResearchElementDefinitionUnitOfMeasure["CSt"] = "cSt";
+    ResearchElementDefinitionUnitOfMeasure["%{breakdown}"] = "%{breakdown}";
+    ResearchElementDefinitionUnitOfMeasure["{rel_saturation}"] = "{rel_saturation}";
+    ResearchElementDefinitionUnitOfMeasure["Fmol/g"] = "fmol/g";
+    ResearchElementDefinitionUnitOfMeasure["{Pouches}/wk"] = "{Pouches}/wk";
+    ResearchElementDefinitionUnitOfMeasure["Umol/mL"] = "umol/mL";
+    ResearchElementDefinitionUnitOfMeasure["Kg/s"] = "kg/s";
+    ResearchElementDefinitionUnitOfMeasure["Bq"] = "Bq";
+    ResearchElementDefinitionUnitOfMeasure["KPa"] = "kPa";
+    ResearchElementDefinitionUnitOfMeasure["Mosm/kg"] = "mosm/kg";
+    ResearchElementDefinitionUnitOfMeasure["Mg/L"] = "mg/L";
+    ResearchElementDefinitionUnitOfMeasure["Meq/kg"] = "meq/kg";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/(24.h)"] = "nmol/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["U/mol"] = "U/mol";
+    ResearchElementDefinitionUnitOfMeasure["T"] = "T";
+    ResearchElementDefinitionUnitOfMeasure["K[IU]/mL"] = "k[IU]/mL";
+    ResearchElementDefinitionUnitOfMeasure["B[V]"] = "B[V]";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/g"] = "pmol/g";
+    ResearchElementDefinitionUnitOfMeasure["Num10*5"] = "10*5";
+    ResearchElementDefinitionUnitOfMeasure["Cm"] = "cm";
+    ResearchElementDefinitionUnitOfMeasure["{WhiteBloodCell}"] = "{WhiteBloodCell}";
+    ResearchElementDefinitionUnitOfMeasure["{MPS'U}"] = "{MPS'U}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/g{dry_wt}"] = "nmol/g{dry_wt}";
+    ResearchElementDefinitionUnitOfMeasure["Gf"] = "gf";
+    ResearchElementDefinitionUnitOfMeasure["{MPortionPhospholipids}"] = "{M-PortionPhospholipids}";
+    ResearchElementDefinitionUnitOfMeasure["{titer}"] = "{titer}";
+    ResearchElementDefinitionUnitOfMeasure["/g"] = "/g";
+    ResearchElementDefinitionUnitOfMeasure["{Breaths}/min"] = "{Breaths}/min";
+    ResearchElementDefinitionUnitOfMeasure["KU/mL"] = "kU/mL";
+    ResearchElementDefinitionUnitOfMeasure["[rd_us]"] = "[rd_us]";
+    ResearchElementDefinitionUnitOfMeasure["U{37Cel}/L"] = "U{37Cel}/L";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/H/mg{protein}"] = "pmol/H/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["[fth_us]"] = "[fth_us]";
+    ResearchElementDefinitionUnitOfMeasure["Fmol/mg{cyt_prot}"] = "fmol/mg{cyt_prot}";
+    ResearchElementDefinitionUnitOfMeasure["G/(kg.h)"] = "g/(kg.h)";
+    ResearchElementDefinitionUnitOfMeasure["%{vol}"] = "%{vol}";
+    ResearchElementDefinitionUnitOfMeasure["/{entity}"] = "/{entity}";
+    ResearchElementDefinitionUnitOfMeasure["Mol/mol"] = "mol/mol";
+    ResearchElementDefinitionUnitOfMeasure["Umol/h/g"] = "umol/h/g";
+    ResearchElementDefinitionUnitOfMeasure["Dm"] = "dm";
+    ResearchElementDefinitionUnitOfMeasure["[ston_av]"] = "[ston_av]";
+    ResearchElementDefinitionUnitOfMeasure["G/g{Cre}"] = "g/g{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["%{Inhibition}"] = "%{Inhibition}";
+    ResearchElementDefinitionUnitOfMeasure["Mol"] = "mol";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/h/mg{prot}"] = "pmol/h/mg{prot}";
+    ResearchElementDefinitionUnitOfMeasure["K"] = "K";
+    ResearchElementDefinitionUnitOfMeasure["{ComplementActivityEnzyme'U}"] = "{ComplementActivityEnzyme'U}";
+    ResearchElementDefinitionUnitOfMeasure["%{WeightToWeight}"] = "%{WeightToWeight}";
+    ResearchElementDefinitionUnitOfMeasure["%{bacteria}"] = "%{bacteria}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/(8.h.kg)"] = "mg/(8.h.kg)";
+    ResearchElementDefinitionUnitOfMeasure["Cm[H2O]/(s.m)"] = "cm[H2O]/(s.m)";
+    ResearchElementDefinitionUnitOfMeasure["[smi_us]"] = "[smi_us]";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/min"] = "nmol/min";
+    ResearchElementDefinitionUnitOfMeasure["%{Bound}"] = "%{Bound}";
+    ResearchElementDefinitionUnitOfMeasure["G/kg"] = "g/kg";
+    ResearchElementDefinitionUnitOfMeasure["Att"] = "att";
+    ResearchElementDefinitionUnitOfMeasure["Mg/L{RBCs}"] = "mg/L{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["ML/(72.h)"] = "mL/(72.h)";
+    ResearchElementDefinitionUnitOfMeasure["G.m/{hb}"] = "g.m/{hb}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/m2"] = "ug/m2";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/umol"] = "pmol/umol";
+    ResearchElementDefinitionUnitOfMeasure["Meq/(kg.d)"] = "meq/(kg.d)";
+    ResearchElementDefinitionUnitOfMeasure["Num10*3{Copies}/mL"] = "10*3{Copies}/mL";
+    ResearchElementDefinitionUnitOfMeasure["Mg/kg/(24.h)"] = "mg/kg/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["Mm[Hg]"] = "mm[Hg]";
+    ResearchElementDefinitionUnitOfMeasure["Ug/dL{rbc}"] = "ug/dL{rbc}";
+    ResearchElementDefinitionUnitOfMeasure["U/10*6"] = "U/10*6";
+    ResearchElementDefinitionUnitOfMeasure["Ng/d"] = "ng/d";
+    ResearchElementDefinitionUnitOfMeasure["[USP'U]"] = "[USP'U]";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/(2.h)"] = "mmol/(2.h)";
+    ResearchElementDefinitionUnitOfMeasure["Num10.uN.s/(cm.m2)"] = "10.uN.s/(cm.m2)";
+    ResearchElementDefinitionUnitOfMeasure["[in_us]"] = "[in_us]";
+    ResearchElementDefinitionUnitOfMeasure["Fmol"] = "fmol";
+    ResearchElementDefinitionUnitOfMeasure["Fmol/mg{protein}"] = "fmol/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/L/mmol{creat}"] = "nmol/L/mmol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["[Btu]"] = "[Btu]";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/{RBC}"] = "pmol/{RBC}";
+    ResearchElementDefinitionUnitOfMeasure["/10*3.{RBCs}"] = "/10*3.{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["G/mmol{creat}"] = "g/mmol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["{AntibodyResponse'U}"] = "{AntibodyResponse'U}";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/kg"] = "[IU]/kg";
+    ResearchElementDefinitionUnitOfMeasure["U/kg{hemoglobin}"] = "U/kg{hemoglobin}";
+    ResearchElementDefinitionUnitOfMeasure["MU/mg"] = "mU/mg";
+    ResearchElementDefinitionUnitOfMeasure["Cm[H2O]"] = "cm[H2O]";
+    ResearchElementDefinitionUnitOfMeasure["AU"] = "AU";
+    ResearchElementDefinitionUnitOfMeasure["Pg/{RBC}"] = "pg/{RBC}";
+    ResearchElementDefinitionUnitOfMeasure["%{reactive}"] = "%{reactive}";
+    ResearchElementDefinitionUnitOfMeasure["G/g{globulin}"] = "g/g{globulin}";
+    ResearchElementDefinitionUnitOfMeasure["{cells}"] = "{cells}";
+    ResearchElementDefinitionUnitOfMeasure["%{Live}"] = "%{Live}";
+    ResearchElementDefinitionUnitOfMeasure["[pwt_tr]"] = "[pwt_tr]";
+    ResearchElementDefinitionUnitOfMeasure["[ligne]"] = "[ligne]";
+    ResearchElementDefinitionUnitOfMeasure["{IFA_index}"] = "{IFA_index}";
+    ResearchElementDefinitionUnitOfMeasure["MU/mL/min"] = "mU/mL/min";
+    ResearchElementDefinitionUnitOfMeasure["Num10*"] = "10*";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/min/mg{prot}"] = "pmol/min/mg{prot}";
+    ResearchElementDefinitionUnitOfMeasure["[G]"] = "[G]";
+    ResearchElementDefinitionUnitOfMeasure["ML/(24.h)"] = "mL/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["[ka'U]"] = "[ka'U]";
+    ResearchElementDefinitionUnitOfMeasure["G/L"] = "g/L";
+    ResearchElementDefinitionUnitOfMeasure["/100"] = "/100";
+    ResearchElementDefinitionUnitOfMeasure["Ng/mL{rbc}"] = "ng/mL{rbc}";
+    ResearchElementDefinitionUnitOfMeasure["st"] = "st";
+    ResearchElementDefinitionUnitOfMeasure["Umol/mol"] = "umol/mol";
+    ResearchElementDefinitionUnitOfMeasure["Kat/L"] = "kat/L";
+    ResearchElementDefinitionUnitOfMeasure["U/g{hemoglobin}"] = "U/g{hemoglobin}";
+    ResearchElementDefinitionUnitOfMeasure["KU/L{class}"] = "kU/L{class}";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/mg{prot}"] = "pmol/mg{prot}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/h/mg{protein}"] = "nmol/h/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["Num10*3{copies}/mL"] = "10*3{copies}/mL";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/h"] = "mmol/h";
+    ResearchElementDefinitionUnitOfMeasure["[ppth]"] = "[ppth]";
+    ResearchElementDefinitionUnitOfMeasure["{genomes}/mL"] = "{genomes}/mL";
+    ResearchElementDefinitionUnitOfMeasure["Mmol"] = "mmol";
+    ResearchElementDefinitionUnitOfMeasure["Gon"] = "gon";
+    ResearchElementDefinitionUnitOfMeasure["Ng/dL/h"] = "ng/dL/h";
+    ResearchElementDefinitionUnitOfMeasure["Mg/mmol"] = "mg/mmol";
+    ResearchElementDefinitionUnitOfMeasure["Mg/mmol{Cre}"] = "mg/mmol{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["/100{neutrophils}"] = "/100{neutrophils}";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/(18.h)"] = "mmol/(18.h)";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/min"] = "mmol/min";
+    ResearchElementDefinitionUnitOfMeasure["{spermatozoa}/mL"] = "{spermatozoa}/mL";
+    ResearchElementDefinitionUnitOfMeasure["Mg/mg{Cre}"] = "mg/mg{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/kg/h"] = "ng/kg/h";
+    ResearchElementDefinitionUnitOfMeasure["Ug/(kg.h)"] = "ug/(kg.h)";
+    ResearchElementDefinitionUnitOfMeasure["{ToxoplasmaIndexValue}"] = "{ToxoplasmaIndexValue}";
+    ResearchElementDefinitionUnitOfMeasure["/[IU]"] = "/[IU]";
+    ResearchElementDefinitionUnitOfMeasure["/d"] = "/d";
+    ResearchElementDefinitionUnitOfMeasure["Mg/(10.h)"] = "mg/(10.h)";
+    ResearchElementDefinitionUnitOfMeasure["[cin_i]"] = "[cin_i]";
+    ResearchElementDefinitionUnitOfMeasure["[oz_av]"] = "[oz_av]";
+    ResearchElementDefinitionUnitOfMeasure["Ng/10*6"] = "ng/10*6";
+    ResearchElementDefinitionUnitOfMeasure["%{HemoglobinA1C}"] = "%{HemoglobinA1C}";
+    ResearchElementDefinitionUnitOfMeasure["{Ehrlich'U}/mL"] = "{Ehrlich'U}/mL";
+    ResearchElementDefinitionUnitOfMeasure["{Applicator}"] = "{Applicator}";
+    ResearchElementDefinitionUnitOfMeasure["Pmol"] = "pmol";
+    ResearchElementDefinitionUnitOfMeasure["M[IU]/mL"] = "m[IU]/mL";
+    ResearchElementDefinitionUnitOfMeasure["Mg/g{creat}"] = "mg/g{creat}";
+    ResearchElementDefinitionUnitOfMeasure["U/mL"] = "U/mL";
+    ResearchElementDefinitionUnitOfMeasure["[scwt_av]"] = "[scwt_av]";
+    ResearchElementDefinitionUnitOfMeasure["[cicero]"] = "[cicero]";
+    ResearchElementDefinitionUnitOfMeasure["s"] = "s";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/(5.h)"] = "mmol/(5.h)";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/h/mg{protein}"] = "pmol/h/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["{ElisaU}/mL"] = "{ElisaU}/mL";
+    ResearchElementDefinitionUnitOfMeasure["Num10*12/L"] = "10*12/L";
+    ResearchElementDefinitionUnitOfMeasure["G%"] = "g%";
+    ResearchElementDefinitionUnitOfMeasure["Mol/mL"] = "mol/mL";
+    ResearchElementDefinitionUnitOfMeasure["Meq/dL"] = "meq/dL";
+    ResearchElementDefinitionUnitOfMeasure["Lx"] = "lx";
+    ResearchElementDefinitionUnitOfMeasure["{Bottle}"] = "{Bottle}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol{ATP}"] = "nmol{ATP}";
+    ResearchElementDefinitionUnitOfMeasure["Lm"] = "lm";
+    ResearchElementDefinitionUnitOfMeasure["Ng/mL/h"] = "ng/mL/h";
+    ResearchElementDefinitionUnitOfMeasure["Ug/g{Tissue}"] = "ug/g{Tissue}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/dL{GF}"] = "umol/dL{GF}";
+    ResearchElementDefinitionUnitOfMeasure["/kg{body'wt}"] = "/kg{body'wt}";
+    ResearchElementDefinitionUnitOfMeasure["{rbc}"] = "{rbc}";
+    ResearchElementDefinitionUnitOfMeasure["Ug{T4}/dL"] = "ug{T4}/dL";
+    ResearchElementDefinitionUnitOfMeasure["Umol/mmol"] = "umol/mmol";
+    ResearchElementDefinitionUnitOfMeasure["Num10*3/uL"] = "10*3/uL";
+    ResearchElementDefinitionUnitOfMeasure["{Log_copies}/mL"] = "{Log_copies}/mL";
+    ResearchElementDefinitionUnitOfMeasure["Fmol/mg"] = "fmol/mg";
+    ResearchElementDefinitionUnitOfMeasure["Lm/m2"] = "lm/m2";
+    ResearchElementDefinitionUnitOfMeasure["%{blockade}"] = "%{blockade}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/mL{class}"] = "ug/mL{class}";
+    ResearchElementDefinitionUnitOfMeasure["MU/min"] = "mU/min";
+    ResearchElementDefinitionUnitOfMeasure["Gy"] = "Gy";
+    ResearchElementDefinitionUnitOfMeasure["Num10*3"] = "10*3";
+    ResearchElementDefinitionUnitOfMeasure["/[HPF]"] = "/[HPF]";
+    ResearchElementDefinitionUnitOfMeasure["{M.o.M}"] = "{M.o.M}";
+    ResearchElementDefinitionUnitOfMeasure["Pg/mL"] = "pg/mL";
+    ResearchElementDefinitionUnitOfMeasure["{JDF'U}"] = "{JDF'U}";
+    ResearchElementDefinitionUnitOfMeasure["A_t"] = "a_t";
+    ResearchElementDefinitionUnitOfMeasure["Ug/g{Hgb}"] = "ug/g{Hgb}";
+    ResearchElementDefinitionUnitOfMeasure["[sin_i]"] = "[sin_i]";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/h/mL"] = "pmol/h/mL";
+    ResearchElementDefinitionUnitOfMeasure["U{25Cel}/L"] = "U{25Cel}/L";
+    ResearchElementDefinitionUnitOfMeasure["Num10^"] = "10^";
+    ResearchElementDefinitionUnitOfMeasure["{WBCs}"] = "{WBCs}";
+    ResearchElementDefinitionUnitOfMeasure["{4 times}/d"] = "{4 times}/d";
+    ResearchElementDefinitionUnitOfMeasure["Ci"] = "Ci";
+    ResearchElementDefinitionUnitOfMeasure["Mg/g{tissue}"] = "mg/g{tissue}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/ng"] = "ug/ng";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/L{37Cel}"] = "[IU]/L{37Cel}";
+    ResearchElementDefinitionUnitOfMeasure["Pa"] = "Pa";
+    ResearchElementDefinitionUnitOfMeasure["{ERY}/uL"] = "{ERY}/uL";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/umol{creat}"] = "pmol/umol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["{binding_index}"] = "{binding_index}";
+    ResearchElementDefinitionUnitOfMeasure["MeV"] = "MeV";
+    ResearchElementDefinitionUnitOfMeasure["B[kW]"] = "B[kW]";
+    ResearchElementDefinitionUnitOfMeasure["Mg/kg/d"] = "mg/kg/d";
+    ResearchElementDefinitionUnitOfMeasure["/ug"] = "/ug";
+    ResearchElementDefinitionUnitOfMeasure["GBq"] = "GBq";
+    ResearchElementDefinitionUnitOfMeasure["Ug/(kg.d)"] = "ug/(kg.d)";
+    ResearchElementDefinitionUnitOfMeasure["[tsp_us]"] = "[tsp_us]";
+    ResearchElementDefinitionUnitOfMeasure["Mg/g{dry_tissue}"] = "mg/g{dry_tissue}";
+    ResearchElementDefinitionUnitOfMeasure["/10*3"] = "/10*3";
+    ResearchElementDefinitionUnitOfMeasure["UOhm"] = "uOhm";
+    ResearchElementDefinitionUnitOfMeasure["ML/(8.h)"] = "mL/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["/100{spermatozoa}"] = "/100{spermatozoa}";
+    ResearchElementDefinitionUnitOfMeasure["Fmol/mL"] = "fmol/mL";
+    ResearchElementDefinitionUnitOfMeasure["{# of fetuses}"] = "{# of fetuses}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/mL{eqv}"] = "ug/mL{eqv}";
+    ResearchElementDefinitionUnitOfMeasure["{Packs}/d"] = "{Packs}/d";
+    ResearchElementDefinitionUnitOfMeasure["[S]"] = "[S]";
+    ResearchElementDefinitionUnitOfMeasure["G/min"] = "g/min";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mol"] = "nmol/mol";
+    ResearchElementDefinitionUnitOfMeasure["MU"] = "mU";
+    ResearchElementDefinitionUnitOfMeasure["Ug"] = "ug";
+    ResearchElementDefinitionUnitOfMeasure["Ml"] = "ml";
+    ResearchElementDefinitionUnitOfMeasure["%[slope]"] = "%[slope]";
+    ResearchElementDefinitionUnitOfMeasure["MU/mg{creat}"] = "mU/mg{creat}";
+    ResearchElementDefinitionUnitOfMeasure["G.m/{beat}"] = "g.m/{beat}";
+    ResearchElementDefinitionUnitOfMeasure["Num1/d"] = "1/d";
+    ResearchElementDefinitionUnitOfMeasure["B[mV]"] = "B[mV]";
+    ResearchElementDefinitionUnitOfMeasure["MBq"] = "MBq";
+    ResearchElementDefinitionUnitOfMeasure["UU"] = "uU";
+    ResearchElementDefinitionUnitOfMeasure["[PRU]"] = "[PRU]";
+    ResearchElementDefinitionUnitOfMeasure["{Cells}/mL"] = "{Cells}/mL";
+    ResearchElementDefinitionUnitOfMeasure["L/(min.m2)"] = "L/(min.m2)";
+    ResearchElementDefinitionUnitOfMeasure["Ug/L"] = "ug/L";
+    ResearchElementDefinitionUnitOfMeasure["Kg/m2"] = "kg/m2";
+    ResearchElementDefinitionUnitOfMeasure["[smoot]"] = "[smoot]";
+    ResearchElementDefinitionUnitOfMeasure["Ug/dL"] = "ug/dL";
+    ResearchElementDefinitionUnitOfMeasure["[p'diop]"] = "[p'diop]";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mg{prot}"] = "nmol/mg{prot}";
+    ResearchElementDefinitionUnitOfMeasure["[ppm]"] = "[ppm]";
+    ResearchElementDefinitionUnitOfMeasure["%{Total}"] = "%{Total}";
+    ResearchElementDefinitionUnitOfMeasure["G/(24.h)"] = "g/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["Num10*Num3{Polarization'U}"] = "10*-3{Polarization'U}";
+    ResearchElementDefinitionUnitOfMeasure["Pm"] = "pm";
+    ResearchElementDefinitionUnitOfMeasure["Umol/h/mg{protein}"] = "umol/h/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["G{total_prot}"] = "g{total_prot}";
+    ResearchElementDefinitionUnitOfMeasure["/10*9"] = "/10*9";
+    ResearchElementDefinitionUnitOfMeasure["/g{wet_tis}"] = "/g{wet_tis}";
+    ResearchElementDefinitionUnitOfMeasure["%{inhibition}"] = "%{inhibition}";
+    ResearchElementDefinitionUnitOfMeasure["/100{cells}"] = "/100{cells}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/min/mg{prot}"] = "nmol/min/mg{prot}";
+    ResearchElementDefinitionUnitOfMeasure["B[SPL]"] = "B[SPL]";
+    ResearchElementDefinitionUnitOfMeasure["{Events}"] = "{Events}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/kg"] = "ng/kg";
+    ResearchElementDefinitionUnitOfMeasure["[gal_br]"] = "[gal_br]";
+    ResearchElementDefinitionUnitOfMeasure["/a"] = "/a";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/m/mg{prot}"] = "nmol/m/mg{prot}";
+    ResearchElementDefinitionUnitOfMeasure["{#}/[LPF]"] = "{#}/[LPF]";
+    ResearchElementDefinitionUnitOfMeasure["G/{total_weight}"] = "g/{total_weight}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mg{protein}"] = "nmol/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["[fdr_us]"] = "[fdr_us]";
+    ResearchElementDefinitionUnitOfMeasure["Ug/mg"] = "ug/mg";
+    ResearchElementDefinitionUnitOfMeasure["Ug/{specimen}"] = "ug/{specimen}";
+    ResearchElementDefinitionUnitOfMeasure["U/(24.h)"] = "U/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/mmol"] = "mmol/mmol";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/kg/h"] = "mmol/kg/h";
+    ResearchElementDefinitionUnitOfMeasure["Ug{FEU}/mL"] = "ug{FEU}/mL";
+    ResearchElementDefinitionUnitOfMeasure["ML"] = "mL";
+    ResearchElementDefinitionUnitOfMeasure["ML/[sin_i]"] = "mL/[sin_i]";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6/(24.h)"] = "10*6/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["U/min"] = "U/min";
+    ResearchElementDefinitionUnitOfMeasure["ML/d"] = "mL/d";
+    ResearchElementDefinitionUnitOfMeasure["[APL'U]/mL"] = "[APL'U]/mL";
+    ResearchElementDefinitionUnitOfMeasure["''"] = "''";
+    ResearchElementDefinitionUnitOfMeasure["%{0to3Hours}"] = "%{0to3Hours}";
+    ResearchElementDefinitionUnitOfMeasure["[lbf_av]"] = "[lbf_av]";
+    ResearchElementDefinitionUnitOfMeasure["H/wk"] = "h/wk";
+    ResearchElementDefinitionUnitOfMeasure["/10*12{RBCs}"] = "/10*12{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["/h"] = "/h";
+    ResearchElementDefinitionUnitOfMeasure["%{Hemolysis}"] = "%{Hemolysis}";
+    ResearchElementDefinitionUnitOfMeasure["/kg"] = "/kg";
+    ResearchElementDefinitionUnitOfMeasure["U/g{Hb}"] = "U/g{Hb}";
+    ResearchElementDefinitionUnitOfMeasure["[MPL'U]"] = "[MPL'U]";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/mol{creat}"] = "mmol/mol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/g{wet_tissue}"] = "mg/g{wet_tissue}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/L{RBCs}"] = "umol/L{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["Rad"] = "rad";
+    ResearchElementDefinitionUnitOfMeasure["Ueq"] = "ueq";
+    ResearchElementDefinitionUnitOfMeasure["Ohm.m"] = "Ohm.m";
+    ResearchElementDefinitionUnitOfMeasure["{OpticalDensityIndex}"] = "{OpticalDensityIndex}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/(kg.h)"] = "ng/(kg.h)";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/kg/min"] = "mmol/kg/min";
+    ResearchElementDefinitionUnitOfMeasure["Num10.L/(min.m2)"] = "10.L/(min.m2)";
+    ResearchElementDefinitionUnitOfMeasure["%{BasalActivity}"] = "%{BasalActivity}";
+    ResearchElementDefinitionUnitOfMeasure["[APL'U]"] = "[APL'U]";
+    ResearchElementDefinitionUnitOfMeasure["[Btu_39]"] = "[Btu_39]";
+    ResearchElementDefinitionUnitOfMeasure["Ng/mg"] = "ng/mg";
+    ResearchElementDefinitionUnitOfMeasure["B[W]"] = "B[W]";
+    ResearchElementDefinitionUnitOfMeasure["DL"] = "dL";
+    ResearchElementDefinitionUnitOfMeasure["{CGG_repeats}"] = "{CGG_repeats}";
+    ResearchElementDefinitionUnitOfMeasure["U/kg{Hb}"] = "U/kg{Hb}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/(kg.h)"] = "mg/(kg.h)";
+    ResearchElementDefinitionUnitOfMeasure["Num10*9/mL"] = "10*9/mL";
+    ResearchElementDefinitionUnitOfMeasure["Nm"] = "nm";
+    ResearchElementDefinitionUnitOfMeasure["Ng/L"] = "ng/L";
+    ResearchElementDefinitionUnitOfMeasure["{mutation}"] = "{mutation}";
+    ResearchElementDefinitionUnitOfMeasure["EV"] = "eV";
+    ResearchElementDefinitionUnitOfMeasure["[drp]/[HPF]"] = "[drp]/[HPF]";
+    ResearchElementDefinitionUnitOfMeasure["%{response}"] = "%{response}";
+    ResearchElementDefinitionUnitOfMeasure["/min"] = "/min";
+    ResearchElementDefinitionUnitOfMeasure["/[LPF]"] = "/[LPF]";
+    ResearchElementDefinitionUnitOfMeasure["[pca]"] = "[pca]";
+    ResearchElementDefinitionUnitOfMeasure["[pk_us]"] = "[pk_us]";
+    ResearchElementDefinitionUnitOfMeasure["{ComplementCH50'U}"] = "{ComplementCH50'U}";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6.[IU]"] = "10*6.[IU]";
+    ResearchElementDefinitionUnitOfMeasure["M/s2"] = "m/s2";
+    ResearchElementDefinitionUnitOfMeasure["{cells}/uL"] = "{cells}/uL";
+    ResearchElementDefinitionUnitOfMeasure["%{WBCs}"] = "%{WBCs}";
+    ResearchElementDefinitionUnitOfMeasure["Meq/g"] = "meq/g";
+    ResearchElementDefinitionUnitOfMeasure["{3 times}/d"] = "{3 times}/d";
+    ResearchElementDefinitionUnitOfMeasure["{GPortionPhospholipids}"] = "{G-PortionPhospholipids}";
+    ResearchElementDefinitionUnitOfMeasure["Umol"] = "umol";
+    ResearchElementDefinitionUnitOfMeasure["Fmol/L"] = "fmol/L";
+    ResearchElementDefinitionUnitOfMeasure["Umol/mol{creat}"] = "umol/mol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["{Volume}/{Vvolume}"] = "{Volume}/{Vvolume}";
+    ResearchElementDefinitionUnitOfMeasure["Wb"] = "Wb";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/min/mg{Hb}"] = "nmol/min/mg{Hb}";
+    ResearchElementDefinitionUnitOfMeasure["{ARU}"] = "{ARU}";
+    ResearchElementDefinitionUnitOfMeasure["ML/{beat}"] = "mL/{beat}";
+    ResearchElementDefinitionUnitOfMeasure["{Dose}"] = "{Dose}";
+    ResearchElementDefinitionUnitOfMeasure["Ukat"] = "ukat";
+    ResearchElementDefinitionUnitOfMeasure["Mm3"] = "mm3";
+    ResearchElementDefinitionUnitOfMeasure["{Dalton}"] = "{Dalton}";
+    ResearchElementDefinitionUnitOfMeasure["L"] = "L";
+    ResearchElementDefinitionUnitOfMeasure["U/g{Cre}"] = "U/g{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["{#}"] = "{#}";
+    ResearchElementDefinitionUnitOfMeasure["mv"] = "mV";
+    ResearchElementDefinitionUnitOfMeasure["%{binding}"] = "%{binding}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mg{prot}/h"] = "nmol/mg{prot}/h";
+    ResearchElementDefinitionUnitOfMeasure["Mg"] = "mg";
+    ResearchElementDefinitionUnitOfMeasure["%{pooled_plasma}"] = "%{pooled_plasma}";
+    ResearchElementDefinitionUnitOfMeasure["{OpticalDensity}"] = "{OpticalDensity}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/{TotalVolume}"] = "ug/{TotalVolume}";
+    ResearchElementDefinitionUnitOfMeasure["%{NormalControl}"] = "%{NormalControl}";
+    ResearchElementDefinitionUnitOfMeasure["{Log}"] = "{Log}";
+    ResearchElementDefinitionUnitOfMeasure["[m_p]"] = "[m_p]";
+    ResearchElementDefinitionUnitOfMeasure["%/100{WBC}"] = "%/100{WBC}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/{Specimen}"] = "mg/{Specimen}";
+    ResearchElementDefinitionUnitOfMeasure["Kcal/kg/(24.h)"] = "kcal/kg/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["Ug/mg{Cre}"] = "ug/mg{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["[LPF]"] = "[LPF]";
+    ResearchElementDefinitionUnitOfMeasure["M2"] = "m2";
+    ResearchElementDefinitionUnitOfMeasure["Num1"] = "1";
+    ResearchElementDefinitionUnitOfMeasure["Bit"] = "bit";
+    ResearchElementDefinitionUnitOfMeasure["{CPM}"] = "{CPM}";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6/L"] = "10*6/L";
+    ResearchElementDefinitionUnitOfMeasure["Ug/g{DryWeight}"] = "ug/g{DryWeight}";
+    ResearchElementDefinitionUnitOfMeasure["[hp_M]"] = "[hp_M]";
+    ResearchElementDefinitionUnitOfMeasure["/10*6"] = "/10*6";
+    ResearchElementDefinitionUnitOfMeasure["Ng{FEU}/mL"] = "ng{FEU}/mL";
+    ResearchElementDefinitionUnitOfMeasure["{Package}"] = "{Package}";
+    ResearchElementDefinitionUnitOfMeasure["Ueq/mL"] = "ueq/mL";
+    ResearchElementDefinitionUnitOfMeasure["Mg/mmol{creat}"] = "mg/mmol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/g{creat}"] = "umol/g{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Mol/m3"] = "mol/m3";
+    ResearchElementDefinitionUnitOfMeasure["MU/g{Hgb}"] = "mU/g{Hgb}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mmol{creat}"] = "nmol/mmol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["%{loss_AChR}"] = "%{loss_AChR}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/min/L"] = "umol/min/L";
+    ResearchElementDefinitionUnitOfMeasure["Mol/L"] = "mol/L";
+    ResearchElementDefinitionUnitOfMeasure["Ky"] = "Ky";
+    ResearchElementDefinitionUnitOfMeasure["{Molecule}/{Platelet}"] = "{Molecule}/{Platelet}";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/dL"] = "mmol/dL";
+    ResearchElementDefinitionUnitOfMeasure["Num10*3/L"] = "10*3/L";
+    ResearchElementDefinitionUnitOfMeasure["Pg/mg{creat}"] = "pg/mg{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Meq/L"] = "meq/L";
+    ResearchElementDefinitionUnitOfMeasure["%{hemolysis}"] = "%{hemolysis}";
+    ResearchElementDefinitionUnitOfMeasure["G/(8.h){shift}"] = "g/(8.h){shift}";
+    ResearchElementDefinitionUnitOfMeasure["[lk_br]"] = "[lk_br]";
+    ResearchElementDefinitionUnitOfMeasure["L/s"] = "L/s";
+    ResearchElementDefinitionUnitOfMeasure["L/min"] = "L/min";
+    ResearchElementDefinitionUnitOfMeasure["U/g{creat}"] = "U/g{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Mx"] = "Mx";
+    ResearchElementDefinitionUnitOfMeasure["%{Negative Control}"] = "%{Negative Control}";
+    ResearchElementDefinitionUnitOfMeasure["NU/{RBC}"] = "nU/{RBC}";
+    ResearchElementDefinitionUnitOfMeasure["Erg"] = "erg";
+    ResearchElementDefinitionUnitOfMeasure["L/h"] = "L/h";
+    ResearchElementDefinitionUnitOfMeasure["%{TotalProtein}"] = "%{TotalProtein}";
+    ResearchElementDefinitionUnitOfMeasure["K[IU]/L"] = "k[IU]/L";
+    ResearchElementDefinitionUnitOfMeasure["Mg/{Tot'Volume}"] = "mg/{Tot'Volume}";
+    ResearchElementDefinitionUnitOfMeasure["%{abnormal}"] = "%{abnormal}";
+    ResearchElementDefinitionUnitOfMeasure["[in_i'H2O]"] = "[in_i'H2O]";
+    ResearchElementDefinitionUnitOfMeasure["Ms"] = "Ms";
+    ResearchElementDefinitionUnitOfMeasure["{Tscore}"] = "{Tscore}";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/mol{Cre}"] = "mmol/mol{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["KU/h"] = "kU/h";
+    ResearchElementDefinitionUnitOfMeasure["A/m"] = "A/m";
+    ResearchElementDefinitionUnitOfMeasure["Ug/g{Cre}"] = "ug/g{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["[dr_ap]"] = "[dr_ap]";
+    ResearchElementDefinitionUnitOfMeasure["{HaTiter}"] = "{HaTiter}";
+    ResearchElementDefinitionUnitOfMeasure["Kat"] = "kat";
+    ResearchElementDefinitionUnitOfMeasure["{copies}/mL"] = "{copies}/mL";
+    ResearchElementDefinitionUnitOfMeasure["ML/min"] = "mL/min";
+    ResearchElementDefinitionUnitOfMeasure["ML/(12.h)"] = "mL/(12.h)";
+    ResearchElementDefinitionUnitOfMeasure["[hnsf'U]"] = "[hnsf'U]";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6/{Specimen}"] = "10*6/{Specimen}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/mg{protein}"] = "ng/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["/[iU]"] = "/[iU]";
+    ResearchElementDefinitionUnitOfMeasure["Hz"] = "Hz";
+    ResearchElementDefinitionUnitOfMeasure["{FIU}"] = "{FIU}";
+    ResearchElementDefinitionUnitOfMeasure["[yd_br]"] = "[yd_br]";
+    ResearchElementDefinitionUnitOfMeasure["{FluorescenceIntensity'U}"] = "{FluorescenceIntensity'U}";
+    ResearchElementDefinitionUnitOfMeasure["{Rubella_virus}"] = "{Rubella_virus}";
+    ResearchElementDefinitionUnitOfMeasure["{P2Y12 Reaction Units}"] = "{P2Y12 Reaction Units}";
+    ResearchElementDefinitionUnitOfMeasure["%{Hemoglobin}"] = "%{Hemoglobin}";
+    ResearchElementDefinitionUnitOfMeasure["[drp]/mL"] = "[drp]/mL";
+    ResearchElementDefinitionUnitOfMeasure["[cyd_i]"] = "[cyd_i]";
+    ResearchElementDefinitionUnitOfMeasure["[fur_us]"] = "[fur_us]";
+    ResearchElementDefinitionUnitOfMeasure["FL"] = "fL";
+    ResearchElementDefinitionUnitOfMeasure["ML/(4.h)"] = "mL/(4.h)";
+    ResearchElementDefinitionUnitOfMeasure["{# of donor informative markers}"] = "{# of donor informative markers}";
+    ResearchElementDefinitionUnitOfMeasure["KV"] = "kV";
+    ResearchElementDefinitionUnitOfMeasure["Mg/m3"] = "mg/m3";
+    ResearchElementDefinitionUnitOfMeasure["[pt_us]"] = "[pt_us]";
+    ResearchElementDefinitionUnitOfMeasure["Ueq/L"] = "ueq/L";
+    ResearchElementDefinitionUnitOfMeasure["%{ofAvailable}"] = "%{ofAvailable}";
+    ResearchElementDefinitionUnitOfMeasure["{phenotype}"] = "{phenotype}";
+    ResearchElementDefinitionUnitOfMeasure["[pc_br]"] = "[pc_br]";
+    ResearchElementDefinitionUnitOfMeasure["G/mL"] = "g/mL";
+    ResearchElementDefinitionUnitOfMeasure["[D'ag'U]"] = "[D'ag'U]";
+    ResearchElementDefinitionUnitOfMeasure["G"] = "G";
+    ResearchElementDefinitionUnitOfMeasure["Mg/kg/(8.h)"] = "mg/kg/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["[HPF]"] = "[HPF]";
+    ResearchElementDefinitionUnitOfMeasure["Ps"] = "ps";
+    ResearchElementDefinitionUnitOfMeasure["L/s/s2"] = "L/s/s2";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6.eq/mL"] = "10*6.eq/mL";
+    ResearchElementDefinitionUnitOfMeasure["KBq"] = "kBq";
+    ResearchElementDefinitionUnitOfMeasure["Mg/d/{1.73_m2}"] = "mg/d/{1.73_m2}";
+    ResearchElementDefinitionUnitOfMeasure["[AU]"] = "[AU]";
+    ResearchElementDefinitionUnitOfMeasure["Ao"] = "Ao";
+    ResearchElementDefinitionUnitOfMeasure["[drp]/h"] = "[drp]/h";
+    ResearchElementDefinitionUnitOfMeasure["ML/(8.h)/kg"] = "mL/(8.h)/kg";
+    ResearchElementDefinitionUnitOfMeasure["Mg/mg{creat}"] = "mg/mg{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/L/(24.h)"] = "ug/L/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["ML/mm"] = "mL/mm";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/L{RBCs}"] = "nmol/L{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["[car_Au]"] = "[car_Au]";
+    ResearchElementDefinitionUnitOfMeasure["Dg"] = "dg";
+    ResearchElementDefinitionUnitOfMeasure["Sr"] = "sr";
+    ResearchElementDefinitionUnitOfMeasure["%{normal}"] = "%{normal}";
+    ResearchElementDefinitionUnitOfMeasure["/{oif}"] = "/{oif}";
+    ResearchElementDefinitionUnitOfMeasure["{ElisaValue}"] = "{ElisaValue}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol{BCE}/mmol{creat}"] = "nmol{BCE}/mmol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/d"] = "mg/d";
+    ResearchElementDefinitionUnitOfMeasure["[Btu_th]"] = "[Btu_th]";
+    ResearchElementDefinitionUnitOfMeasure["[iU]/mL"] = "[iU]/mL";
+    ResearchElementDefinitionUnitOfMeasure["{IndexValue}"] = "{IndexValue}";
+    ResearchElementDefinitionUnitOfMeasure["[GPL'U]/mL"] = "[GPL'U]/mL";
+    ResearchElementDefinitionUnitOfMeasure["{Ct}"] = "{Ct}";
+    ResearchElementDefinitionUnitOfMeasure["{IFA_titer}"] = "{IFA_titer}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/{total_output}"] = "mg/{total_output}";
+    ResearchElementDefinitionUnitOfMeasure["%{lysis}"] = "%{lysis}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/mg"] = "mg/mg";
+    ResearchElementDefinitionUnitOfMeasure["{JuvenileDiabetesFound'U}"] = "{JuvenileDiabetesFound'U}";
+    ResearchElementDefinitionUnitOfMeasure["{Each}"] = "{Each}";
+    ResearchElementDefinitionUnitOfMeasure["[fth_br]"] = "[fth_br]";
+    ResearchElementDefinitionUnitOfMeasure["MU/mmol{RBCs}"] = "mU/mmol{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["{log_IU}/mL"] = "{log_IU}/mL";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/g{Cre}"] = "nmol/g{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["{Copies}/mL"] = "{Copies}/mL";
+    ResearchElementDefinitionUnitOfMeasure["Cal_[15]"] = "cal_[15]";
+    ResearchElementDefinitionUnitOfMeasure["DB"] = "dB";
+    ResearchElementDefinitionUnitOfMeasure["[lb_tr]"] = "[lb_tr]";
+    ResearchElementDefinitionUnitOfMeasure["L/d"] = "L/d";
+    ResearchElementDefinitionUnitOfMeasure["[Btu_m]"] = "[Btu_m]";
+    ResearchElementDefinitionUnitOfMeasure["J"] = "J";
+    ResearchElementDefinitionUnitOfMeasure["MPa.s"] = "mPa.s";
+    ResearchElementDefinitionUnitOfMeasure["[iU]"] = "[iU]";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/kg{H2O}"] = "mmol/kg{H2O}";
+    ResearchElementDefinitionUnitOfMeasure["Mbar/L/s"] = "mbar/L/s";
+    ResearchElementDefinitionUnitOfMeasure["{RubellaVirus}"] = "{RubellaVirus}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/m/mg{protein}"] = "nmol/m/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["Pg/{cell}"] = "pg/{cell}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/wk"] = "mg/wk";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/g{hemoglobin}"] = "mmol/g{hemoglobin}";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/(2.h)"] = "[IU]/(2.h)";
+    ResearchElementDefinitionUnitOfMeasure["{EIATiter}"] = "{EIATiter}";
+    ResearchElementDefinitionUnitOfMeasure["{ISR}"] = "{ISR}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/mL{RBCs}"] = "ng/mL{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["G/(48.h)"] = "g/(48.h)";
+    ResearchElementDefinitionUnitOfMeasure["G/mg"] = "g/mg";
+    ResearchElementDefinitionUnitOfMeasure["FL/nL"] = "fL/nL";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/g"] = "nmol/g";
+    ResearchElementDefinitionUnitOfMeasure["[mu_0]"] = "[mu_0]";
+    ResearchElementDefinitionUnitOfMeasure["/(12.h)"] = "/(12.h)";
+    ResearchElementDefinitionUnitOfMeasure["[pi].rad/min"] = "[pi].rad/min";
+    ResearchElementDefinitionUnitOfMeasure["Ug/kg"] = "ug/kg";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/min"] = "pmol/min";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/min"] = "[IU]/min";
+    ResearchElementDefinitionUnitOfMeasure["Ks"] = "ks";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/m"] = "mmol/m";
+    ResearchElementDefinitionUnitOfMeasure["Ns"] = "ns";
+    ResearchElementDefinitionUnitOfMeasure["Kg{wet'tis}"] = "kg{wet'tis}";
+    ResearchElementDefinitionUnitOfMeasure["Kg/h"] = "kg/h";
+    ResearchElementDefinitionUnitOfMeasure["%{Blockade}"] = "%{Blockade}";
+    ResearchElementDefinitionUnitOfMeasure["{minidrop}/s"] = "{minidrop}/s";
+    ResearchElementDefinitionUnitOfMeasure["G/kg/d"] = "g/kg/d";
+    ResearchElementDefinitionUnitOfMeasure["{KRONU'U}/mL"] = "{KRONU'U}/mL";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/{TotalVolume}"] = "mmol/{TotalVolume}";
+    ResearchElementDefinitionUnitOfMeasure["Mo"] = "mo";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/(6.h)"] = "mmol/(6.h)";
+    ResearchElementDefinitionUnitOfMeasure["{CAG_repeats}"] = "{CAG_repeats}";
+    ResearchElementDefinitionUnitOfMeasure["J/L"] = "J/L";
+    ResearchElementDefinitionUnitOfMeasure["{IgAAntiphosphatidyleserine'U}"] = "{IgAAntiphosphatidyleserine'U}";
+    ResearchElementDefinitionUnitOfMeasure["[BAU]"] = "[BAU]";
+    ResearchElementDefinitionUnitOfMeasure["M"] = "m";
+    ResearchElementDefinitionUnitOfMeasure["Meq/(12.h)"] = "meq/(12.h)";
+    ResearchElementDefinitionUnitOfMeasure["Gal"] = "Gal";
+    ResearchElementDefinitionUnitOfMeasure["[fdr_br]"] = "[fdr_br]";
+    ResearchElementDefinitionUnitOfMeasure["{CPM}/10*3{cell}"] = "{CPM}/10*3{cell}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mg{creat}"] = "nmol/mg{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/h"] = "ug/h";
+    ResearchElementDefinitionUnitOfMeasure["{GAA_repeats}"] = "{GAA_repeats}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/g{tissue}"] = "ug/g{tissue}";
+    ResearchElementDefinitionUnitOfMeasure["[lk_us]"] = "[lk_us]";
+    ResearchElementDefinitionUnitOfMeasure["Num10.uN.s/(cm5.m2)"] = "10.uN.s/(cm5.m2)";
+    ResearchElementDefinitionUnitOfMeasure["Ug/{Specimen}"] = "ug/{Specimen}";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/kg/d"] = "mmol/kg/d";
+    ResearchElementDefinitionUnitOfMeasure["{Bead}"] = "{Bead}";
+    ResearchElementDefinitionUnitOfMeasure["G/{total_output}"] = "g/{total_output}";
+    ResearchElementDefinitionUnitOfMeasure["KU/g"] = "kU/g";
+    ResearchElementDefinitionUnitOfMeasure["PT"] = "pT";
+    ResearchElementDefinitionUnitOfMeasure["/{tot}"] = "/{tot}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/min/10*6{cells}"] = "nmol/min/10*6{cells}";
+    ResearchElementDefinitionUnitOfMeasure["Kg/(s.m2)"] = "kg/(s.m2)";
+    ResearchElementDefinitionUnitOfMeasure["{cfu}"] = "{cfu}";
+    ResearchElementDefinitionUnitOfMeasure["ML/(kg.min)"] = "mL/(kg.min)";
+    ResearchElementDefinitionUnitOfMeasure["ML/{h'b}"] = "mL/{h'b}";
+    ResearchElementDefinitionUnitOfMeasure["[pi]"] = "[pi]";
+    ResearchElementDefinitionUnitOfMeasure["Oe"] = "Oe";
+    ResearchElementDefinitionUnitOfMeasure["UL/(2.h)"] = "uL/(2.h)";
+    ResearchElementDefinitionUnitOfMeasure["UU/g"] = "uU/g";
+    ResearchElementDefinitionUnitOfMeasure["St"] = "St";
+    ResearchElementDefinitionUnitOfMeasure["/g{wet'tis}"] = "/g{wet'tis}";
+    ResearchElementDefinitionUnitOfMeasure["{risk}"] = "{risk}";
+    ResearchElementDefinitionUnitOfMeasure["{INR}"] = "{INR}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/mL"] = "mg/mL";
+    ResearchElementDefinitionUnitOfMeasure["ML/(6.h)"] = "mL/(6.h)";
+    ResearchElementDefinitionUnitOfMeasure["{count}"] = "{count}";
+    ResearchElementDefinitionUnitOfMeasure["[acr_us]"] = "[acr_us]";
+    ResearchElementDefinitionUnitOfMeasure["Ng/mg{prot}"] = "ng/mg{prot}";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6/uL"] = "10*6/uL";
+    ResearchElementDefinitionUnitOfMeasure["{#}/d"] = "{#}/d";
+    ResearchElementDefinitionUnitOfMeasure["{LymeIndexValue}"] = "{LymeIndexValue}";
+    ResearchElementDefinitionUnitOfMeasure["Mho"] = "mho";
+    ResearchElementDefinitionUnitOfMeasure["{index}"] = "{index}";
+    ResearchElementDefinitionUnitOfMeasure["U/g{protein}"] = "U/g{protein}";
+    ResearchElementDefinitionUnitOfMeasure["{#}/wk"] = "{#}/wk";
+    ResearchElementDefinitionUnitOfMeasure["Umol/m"] = "umol/m";
+    ResearchElementDefinitionUnitOfMeasure["Sv"] = "Sv";
+    ResearchElementDefinitionUnitOfMeasure["[lb_av]"] = "[lb_av]";
+    ResearchElementDefinitionUnitOfMeasure["Mol/mol{creat}"] = "mol/mol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["[lcwt_av]"] = "[lcwt_av]";
+    ResearchElementDefinitionUnitOfMeasure["/g{tot_prot}"] = "/g{tot_prot}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/kg/d"] = "ug/kg/d";
+    ResearchElementDefinitionUnitOfMeasure["{KRONU'U}/L"] = "{KRONU'U}/L";
+    ResearchElementDefinitionUnitOfMeasure["[iU]/dL"] = "[iU]/dL";
+    ResearchElementDefinitionUnitOfMeasure["S"] = "S";
+    ResearchElementDefinitionUnitOfMeasure["{IgGAntiphosphatidyleserine'U}"] = "{IgGAntiphosphatidyleserine'U}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/g{hair}"] = "ug/g{hair}";
+    ResearchElementDefinitionUnitOfMeasure["%{baseline}"] = "%{baseline}";
+    ResearchElementDefinitionUnitOfMeasure["{EIA'U}/U"] = "{EIA'U}/U";
+    ResearchElementDefinitionUnitOfMeasure["Umol/g{Cre}"] = "umol/g{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["L.s2/s"] = "L.s2/s";
+    ResearchElementDefinitionUnitOfMeasure["[kn_i]"] = "[kn_i]";
+    ResearchElementDefinitionUnitOfMeasure["G{creat}"] = "g{creat}";
+    ResearchElementDefinitionUnitOfMeasure["[Btu_IT]"] = "[Btu_IT]";
+    ResearchElementDefinitionUnitOfMeasure["Mg{creat}"] = "mg{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/min"] = "ng/min";
+    ResearchElementDefinitionUnitOfMeasure["Ug/mmol{creat}"] = "ug/mmol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["[min_br]"] = "[min_br]";
+    ResearchElementDefinitionUnitOfMeasure["%{SpermMotility}"] = "%{SpermMotility}";
+    ResearchElementDefinitionUnitOfMeasure["[in_i]"] = "[in_i]";
+    ResearchElementDefinitionUnitOfMeasure["{Log_IU}/mL"] = "{Log_IU}/mL";
+    ResearchElementDefinitionUnitOfMeasure["{Ehrlich'U}/100.g"] = "{Ehrlich'U}/100.g";
+    ResearchElementDefinitionUnitOfMeasure["[drp]"] = "[drp]";
+    ResearchElementDefinitionUnitOfMeasure["{Vial}"] = "{Vial}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/dL"] = "mg/dL";
+    ResearchElementDefinitionUnitOfMeasure["Cm[H2O]/L/s"] = "cm[H2O]/L/s";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/umol{creat}"] = "nmol/umol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["{INR'unit}"] = "{INR'unit}";
+    ResearchElementDefinitionUnitOfMeasure["[car_m]"] = "[car_m]";
+    ResearchElementDefinitionUnitOfMeasure["/g{Hb}"] = "/g{Hb}";
+    ResearchElementDefinitionUnitOfMeasure["{#}/min"] = "{#}/min";
+    ResearchElementDefinitionUnitOfMeasure["U/umol"] = "U/umol";
+    ResearchElementDefinitionUnitOfMeasure["{IgGIndex}"] = "{IgGIndex}";
+    ResearchElementDefinitionUnitOfMeasure["ML/(5.h)"] = "mL/(5.h)";
+    ResearchElementDefinitionUnitOfMeasure["{Pill}"] = "{Pill}";
+    ResearchElementDefinitionUnitOfMeasure["[CFU]"] = "[CFU]";
+    ResearchElementDefinitionUnitOfMeasure["{Cans}/wk"] = "{Cans}/wk";
+    ResearchElementDefinitionUnitOfMeasure["[nmi_br]"] = "[nmi_br]";
+    ResearchElementDefinitionUnitOfMeasure["Lm.m2"] = "lm.m2";
+    ResearchElementDefinitionUnitOfMeasure["[nmi_i]"] = "[nmi_i]";
+    ResearchElementDefinitionUnitOfMeasure["H"] = "H";
+    ResearchElementDefinitionUnitOfMeasure["G/(8.h)"] = "g/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["/m3"] = "/m3";
+    ResearchElementDefinitionUnitOfMeasure["M2/s"] = "m2/s";
+    ResearchElementDefinitionUnitOfMeasure["Deg"] = "deg";
+    ResearchElementDefinitionUnitOfMeasure["Mg/(6.h)"] = "mg/(6.h)";
+    ResearchElementDefinitionUnitOfMeasure["[gal_us]"] = "[gal_us]";
+    ResearchElementDefinitionUnitOfMeasure["Cm[Hg]"] = "cm[Hg]";
+    ResearchElementDefinitionUnitOfMeasure["ML/(2.h)"] = "mL/(2.h)";
+    ResearchElementDefinitionUnitOfMeasure["/{Specimen}"] = "/{Specimen}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mg{protein}/h"] = "nmol/mg{protein}/h";
+    ResearchElementDefinitionUnitOfMeasure["{CfTiter}"] = "{CfTiter}";
+    ResearchElementDefinitionUnitOfMeasure["Meq/{total_volume}"] = "meq/{total_volume}";
+    ResearchElementDefinitionUnitOfMeasure["Mosm"] = "mosm";
+    ResearchElementDefinitionUnitOfMeasure["[PNU]"] = "[PNU]";
+    ResearchElementDefinitionUnitOfMeasure["Km"] = "km";
+    ResearchElementDefinitionUnitOfMeasure["Num10.uN.s/cm2"] = "10.uN.s/cm2";
+    ResearchElementDefinitionUnitOfMeasure["[rd_br]"] = "[rd_br]";
+    ResearchElementDefinitionUnitOfMeasure["%{OfWBCs}"] = "%{OfWBCs}";
+    ResearchElementDefinitionUnitOfMeasure["%{Positive}"] = "%{Positive}";
+    ResearchElementDefinitionUnitOfMeasure["{RecTiter}"] = "{RecTiter}";
+    ResearchElementDefinitionUnitOfMeasure["/10*12{rbc}"] = "/10*12{rbc}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/mg{creat}"] = "ug/mg{creat}";
+    ResearchElementDefinitionUnitOfMeasure["ML/mbar"] = "mL/mbar";
+    ResearchElementDefinitionUnitOfMeasure["U/10"] = "U/10";
+    ResearchElementDefinitionUnitOfMeasure["M[iU]"] = "m[iU]";
+    ResearchElementDefinitionUnitOfMeasure["Umol/kg"] = "umol/kg";
+    ResearchElementDefinitionUnitOfMeasure["H/d"] = "h/d";
+    ResearchElementDefinitionUnitOfMeasure["{Can}"] = "{Can}";
+    ResearchElementDefinitionUnitOfMeasure["Cm2/s"] = "cm2/s";
+    ResearchElementDefinitionUnitOfMeasure["Dyn.s/cm"] = "dyn.s/cm";
+    ResearchElementDefinitionUnitOfMeasure["{Ehrlich'U}/(2.h)"] = "{Ehrlich'U}/(2.h)";
+    ResearchElementDefinitionUnitOfMeasure["Min/wk"] = "min/wk";
+    ResearchElementDefinitionUnitOfMeasure["G/kg/(8.h)"] = "g/kg/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["/mg"] = "/mg";
+    ResearchElementDefinitionUnitOfMeasure["ML/s"] = "mL/s";
+    ResearchElementDefinitionUnitOfMeasure["%{saturation}"] = "%{saturation}";
+    ResearchElementDefinitionUnitOfMeasure["Ph"] = "ph";
+    ResearchElementDefinitionUnitOfMeasure["L/kg"] = "L/kg";
+    ResearchElementDefinitionUnitOfMeasure["KU"] = "kU";
+    ResearchElementDefinitionUnitOfMeasure["{delta_OD}"] = "{delta_OD}";
+    ResearchElementDefinitionUnitOfMeasure["Um"] = "um";
+    ResearchElementDefinitionUnitOfMeasure["Um/s"] = "um/s";
+    ResearchElementDefinitionUnitOfMeasure["[drp]/min"] = "[drp]/min";
+    ResearchElementDefinitionUnitOfMeasure["PA"] = "pA";
+    ResearchElementDefinitionUnitOfMeasure["[iU]/L"] = "[iU]/L";
+    ResearchElementDefinitionUnitOfMeasure["[syd_i]"] = "[syd_i]";
+    ResearchElementDefinitionUnitOfMeasure["Umol/mg"] = "umol/mg";
+    ResearchElementDefinitionUnitOfMeasure["%{Uptake}"] = "%{Uptake}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/g"] = "ug/g";
+    ResearchElementDefinitionUnitOfMeasure["{5 times}/d"] = "{5 times}/d";
+    ResearchElementDefinitionUnitOfMeasure["MU/g{Hb}"] = "mU/g{Hb}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/h"] = "mg/h";
+    ResearchElementDefinitionUnitOfMeasure["Num10.L/min"] = "10.L/min";
+    ResearchElementDefinitionUnitOfMeasure["[tbs_us]"] = "[tbs_us]";
+    ResearchElementDefinitionUnitOfMeasure["/mm3"] = "/mm3";
+    ResearchElementDefinitionUnitOfMeasure["A_g"] = "a_g";
+    ResearchElementDefinitionUnitOfMeasure["Umol/g{Hgb}"] = "umol/g{Hgb}";
+    ResearchElementDefinitionUnitOfMeasure["G/g{tissue}"] = "g/g{tissue}";
+    ResearchElementDefinitionUnitOfMeasure["%{total}"] = "%{total}";
+    ResearchElementDefinitionUnitOfMeasure["{score}"] = "{score}";
+    ResearchElementDefinitionUnitOfMeasure["G/mmol"] = "g/mmol";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/L"] = "[IU]/L";
+    ResearchElementDefinitionUnitOfMeasure["Eq/L"] = "eq/L";
+    ResearchElementDefinitionUnitOfMeasure["Meq/(8.h.kg)"] = "meq/(8.h.kg)";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/mL"] = "pmol/mL";
+    ResearchElementDefinitionUnitOfMeasure["ML/kg/min"] = "mL/kg/min";
+    ResearchElementDefinitionUnitOfMeasure["M/s"] = "m/s";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/mmol{creat}"] = "pmol/mmol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Mo_s"] = "mo_s";
+    ResearchElementDefinitionUnitOfMeasure["%"] = "%";
+    ResearchElementDefinitionUnitOfMeasure["Sph"] = "sph";
+    ResearchElementDefinitionUnitOfMeasure["G.m/{H.B.}"] = "g.m/{H.B.}";
+    ResearchElementDefinitionUnitOfMeasure["Kcal"] = "kcal";
+    ResearchElementDefinitionUnitOfMeasure["Mg/m2"] = "mg/m2";
+    ResearchElementDefinitionUnitOfMeasure["{TSI_index}"] = "{TSI_index}";
+    ResearchElementDefinitionUnitOfMeasure["[cup_us]"] = "[cup_us]";
+    ResearchElementDefinitionUnitOfMeasure["N.cm"] = "N.cm";
+    ResearchElementDefinitionUnitOfMeasure["U/10*12"] = "U/10*12";
+    ResearchElementDefinitionUnitOfMeasure["{dilution}"] = "{dilution}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/mL"] = "ug/mL";
+    ResearchElementDefinitionUnitOfMeasure["Mol/kg/s"] = "mol/kg/s";
+    ResearchElementDefinitionUnitOfMeasure["Mg/{total_volume}"] = "mg/{total_volume}";
+    ResearchElementDefinitionUnitOfMeasure["[Ch]"] = "[Ch]";
+    ResearchElementDefinitionUnitOfMeasure["ML/{beat}/m2"] = "mL/{beat}/m2";
+    ResearchElementDefinitionUnitOfMeasure["[IU]"] = "[IU]";
+    ResearchElementDefinitionUnitOfMeasure["{Beats}/min"] = "{Beats}/min";
+    ResearchElementDefinitionUnitOfMeasure["Umol/h"] = "umol/h";
+    ResearchElementDefinitionUnitOfMeasure["{Times}/wk"] = "{Times}/wk";
+    ResearchElementDefinitionUnitOfMeasure["Mm[H2O]"] = "mm[H2O]";
+    ResearchElementDefinitionUnitOfMeasure["Fmol/mg{cytosol_protein}"] = "fmol/mg{cytosol_protein}";
+    ResearchElementDefinitionUnitOfMeasure["%{bound}"] = "%{bound}";
+    ResearchElementDefinitionUnitOfMeasure["[yd_i]"] = "[yd_i]";
+    ResearchElementDefinitionUnitOfMeasure["Mg/kg/min"] = "mg/kg/min";
+    ResearchElementDefinitionUnitOfMeasure["R"] = "R";
+    ResearchElementDefinitionUnitOfMeasure["{Scoop}"] = "{Scoop}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/g{dry_wt}"] = "ug/g{dry_wt}";
+    ResearchElementDefinitionUnitOfMeasure["{Tine'U}"] = "{Tine'U}";
+    ResearchElementDefinitionUnitOfMeasure["{Elisa_U}/mL"] = "{Elisa_U}/mL";
+    ResearchElementDefinitionUnitOfMeasure["UCi"] = "uCi";
+    ResearchElementDefinitionUnitOfMeasure["U/mL{RBC}"] = "U/mL{RBC}";
+    ResearchElementDefinitionUnitOfMeasure["[ft_us]"] = "[ft_us]";
+    ResearchElementDefinitionUnitOfMeasure["[bu_br]"] = "[bu_br]";
+    ResearchElementDefinitionUnitOfMeasure["[in_i'Hg]"] = "[in_i'Hg]";
+    ResearchElementDefinitionUnitOfMeasure["Mg/{Hgb}/g"] = "mg/{Hgb}/g";
+    ResearchElementDefinitionUnitOfMeasure["[dqt_us]"] = "[dqt_us]";
+    ResearchElementDefinitionUnitOfMeasure["C"] = "C";
+    ResearchElementDefinitionUnitOfMeasure["Mg{FEU}/L"] = "mg{FEU}/L";
+    ResearchElementDefinitionUnitOfMeasure["Num10*3.{RBC}"] = "10*3.{RBC}";
+    ResearchElementDefinitionUnitOfMeasure["B[uV]"] = "B[uV]";
+    ResearchElementDefinitionUnitOfMeasure["[m_e]"] = "[m_e]";
+    ResearchElementDefinitionUnitOfMeasure["{#}/a"] = "{#}/a";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/h/mg{prot}"] = "mmol/h/mg{prot}";
+    ResearchElementDefinitionUnitOfMeasure["ms"] = "ms";
+    ResearchElementDefinitionUnitOfMeasure["{breaths}/min"] = "{breaths}/min";
+    ResearchElementDefinitionUnitOfMeasure["Eq/umol"] = "eq/umol";
+    ResearchElementDefinitionUnitOfMeasure["Wk"] = "wk";
+    ResearchElementDefinitionUnitOfMeasure["Meq/{Specimen}"] = "meq/{Specimen}";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/{total_vol}"] = "mmol/{total_vol}";
+    ResearchElementDefinitionUnitOfMeasure["%{viable}"] = "%{viable}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/min"] = "umol/min";
+    ResearchElementDefinitionUnitOfMeasure["Num24.h"] = "24.h";
+    ResearchElementDefinitionUnitOfMeasure["[dpt_us]"] = "[dpt_us]";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/mol"] = "mmol/mol";
+    ResearchElementDefinitionUnitOfMeasure["{GPS'U}"] = "{GPS'U}";
+    ResearchElementDefinitionUnitOfMeasure["Meq/m2"] = "meq/m2";
+    ResearchElementDefinitionUnitOfMeasure["U/(1.h)"] = "U/(1.h)";
+    ResearchElementDefinitionUnitOfMeasure["/L"] = "/L";
+    ResearchElementDefinitionUnitOfMeasure["/[arb'U]"] = "/[arb'U]";
+    ResearchElementDefinitionUnitOfMeasure["[eps_0]"] = "[eps_0]";
+    ResearchElementDefinitionUnitOfMeasure["U[IU]/mL"] = "u[IU]/mL";
+    ResearchElementDefinitionUnitOfMeasure["Kcal/[oz_av]"] = "kcal/[oz_av]";
+    ResearchElementDefinitionUnitOfMeasure["F"] = "F";
+    ResearchElementDefinitionUnitOfMeasure["[ft_us]/[ft_us]"] = "[ft_us]/[ft_us]";
+    ResearchElementDefinitionUnitOfMeasure["/dL"] = "/dL";
+    ResearchElementDefinitionUnitOfMeasure["{STDV}"] = "{STDV}";
+    ResearchElementDefinitionUnitOfMeasure["{ELISA'U}"] = "{ELISA'U}";
+    ResearchElementDefinitionUnitOfMeasure["Cal_th"] = "cal_th";
+    ResearchElementDefinitionUnitOfMeasure["G/d"] = "g/d";
+    ResearchElementDefinitionUnitOfMeasure["U/10*9"] = "U/10*9";
+    ResearchElementDefinitionUnitOfMeasure["MU/mg{Cre}"] = "mU/mg{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["Circ"] = "circ";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/h/mg{prot}"] = "nmol/h/mg{prot}";
+    ResearchElementDefinitionUnitOfMeasure["[ft_br]"] = "[ft_br]";
+    ResearchElementDefinitionUnitOfMeasure["M[H2O]"] = "m[H2O]";
+    ResearchElementDefinitionUnitOfMeasure["%{Binding}"] = "%{Binding}";
+    ResearchElementDefinitionUnitOfMeasure["/{Entity}"] = "/{Entity}";
+    ResearchElementDefinitionUnitOfMeasure["{HA_titer}"] = "{HA_titer}";
+    ResearchElementDefinitionUnitOfMeasure["G/(72.h)"] = "g/(72.h)";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/mg{creat}"] = "[IU]/mg{creat}";
+    ResearchElementDefinitionUnitOfMeasure["L/(8.h)"] = "L/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["/uL"] = "/uL";
+    ResearchElementDefinitionUnitOfMeasure["UL/h"] = "uL/h";
+    ResearchElementDefinitionUnitOfMeasure["Pkat"] = "pkat";
+    ResearchElementDefinitionUnitOfMeasure["{percentile}"] = "{percentile}";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/(24.h)"] = "pmol/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["Umol/d"] = "umol/d";
+    ResearchElementDefinitionUnitOfMeasure["Mo_g"] = "mo_g";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/L"] = "pmol/L";
+    ResearchElementDefinitionUnitOfMeasure["ML/min/(173.10*Num2.m2)"] = "mL/min/(173.10*-2.m2)";
+    ResearchElementDefinitionUnitOfMeasure["[mil_us]"] = "[mil_us]";
+    ResearchElementDefinitionUnitOfMeasure["{index_val}"] = "{index_val}";
+    ResearchElementDefinitionUnitOfMeasure["{JDF'U}/L"] = "{JDF'U}/L";
+    ResearchElementDefinitionUnitOfMeasure["UU/L"] = "uU/L";
+    ResearchElementDefinitionUnitOfMeasure["[srd_us]"] = "[srd_us]";
+    ResearchElementDefinitionUnitOfMeasure["Mg/kg/h"] = "mg/kg/h";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6/kg"] = "10*6/kg";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/{Tot'Volume}"] = "mmol/{Tot'Volume}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/h/L"] = "nmol/h/L";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/g"] = "[IU]/g";
+    ResearchElementDefinitionUnitOfMeasure["{Number}"] = "{Number}";
+    ResearchElementDefinitionUnitOfMeasure["Kcal/(8.h)"] = "kcal/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["MV/s"] = "mV/s";
+    ResearchElementDefinitionUnitOfMeasure["%{residual}"] = "%{residual}";
+    ResearchElementDefinitionUnitOfMeasure["Osm/kg"] = "osm/kg";
+    ResearchElementDefinitionUnitOfMeasure["{KCT'U}"] = "{KCT'U}";
+    ResearchElementDefinitionUnitOfMeasure["{ComplementCH100'U}"] = "{ComplementCH100'U}";
+    ResearchElementDefinitionUnitOfMeasure["{minidrp}"] = "{minidrp}";
+    ResearchElementDefinitionUnitOfMeasure["/10*10"] = "/10*10";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/min/mL"] = "nmol/min/mL";
+    ResearchElementDefinitionUnitOfMeasure["Ng/U"] = "ng/U";
+    ResearchElementDefinitionUnitOfMeasure["B"] = "B";
+    ResearchElementDefinitionUnitOfMeasure["{IgMAntiphosphatidyleserine'U}"] = "{IgMAntiphosphatidyleserine'U}";
+    ResearchElementDefinitionUnitOfMeasure["%{HumanResponse}"] = "%{HumanResponse}";
+    ResearchElementDefinitionUnitOfMeasure["G/{TotalWeight}"] = "g/{TotalWeight}";
+    ResearchElementDefinitionUnitOfMeasure["%{recovery}"] = "%{recovery}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/s"] = "nmol/s";
+    ResearchElementDefinitionUnitOfMeasure["MU/mmol{creatinine}"] = "mU/mmol{creatinine}";
+    ResearchElementDefinitionUnitOfMeasure["/g{HGB}"] = "/g{HGB}";
+    ResearchElementDefinitionUnitOfMeasure["U/10*10{cells}"] = "U/10*10{cells}";
+    ResearchElementDefinitionUnitOfMeasure["{Streptozyme'U}"] = "{Streptozyme'U}";
+    ResearchElementDefinitionUnitOfMeasure["%{penetration}"] = "%{penetration}";
+    ResearchElementDefinitionUnitOfMeasure["/cm[H2O]"] = "/cm[H2O]";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/d"] = "nmol/d";
+    ResearchElementDefinitionUnitOfMeasure["{IfaIndex}"] = "{IfaIndex}";
+    ResearchElementDefinitionUnitOfMeasure["G{total_nit}"] = "g{total_nit}";
+    ResearchElementDefinitionUnitOfMeasure["{Cells}/uL"] = "{Cells}/uL";
+    ResearchElementDefinitionUnitOfMeasure["a"] = "a";
+    ResearchElementDefinitionUnitOfMeasure["U/dL"] = "U/dL";
+    ResearchElementDefinitionUnitOfMeasure["G/kg/(8.h){shift}"] = "g/kg/(8.h){shift}";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/kg/d"] = "[IU]/kg/d";
+    ResearchElementDefinitionUnitOfMeasure["Ug/g{feces}"] = "ug/g{feces}";
+    ResearchElementDefinitionUnitOfMeasure["{Count}"] = "{Count}";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/s/L"] = "mmol/s/L";
+    ResearchElementDefinitionUnitOfMeasure["Num10*8"] = "10*8";
+    ResearchElementDefinitionUnitOfMeasure["{Pan_Bio'U}"] = "{Pan_Bio'U}";
+    ResearchElementDefinitionUnitOfMeasure["[didot]"] = "[didot]";
+    ResearchElementDefinitionUnitOfMeasure["[bu_us]"] = "[bu_us]";
+    ResearchElementDefinitionUnitOfMeasure["Ag/{cell}"] = "ag/{cell}";
+    ResearchElementDefinitionUnitOfMeasure["Cal"] = "cal";
+    ResearchElementDefinitionUnitOfMeasure["%{Abnormal}"] = "%{Abnormal}";
+    ResearchElementDefinitionUnitOfMeasure["[qt_us]"] = "[qt_us]";
+    ResearchElementDefinitionUnitOfMeasure["ML/dL"] = "mL/dL";
+    ResearchElementDefinitionUnitOfMeasure["{#}/g"] = "{#}/g";
+    ResearchElementDefinitionUnitOfMeasure["[diop]"] = "[diop]";
+    ResearchElementDefinitionUnitOfMeasure["[PFU]"] = "[PFU]";
+    ResearchElementDefinitionUnitOfMeasure["{copies}/ug"] = "{copies}/ug";
+    ResearchElementDefinitionUnitOfMeasure["Kg/L"] = "kg/L";
+    ResearchElementDefinitionUnitOfMeasure["Torr"] = "Torr";
+    ResearchElementDefinitionUnitOfMeasure["Ug/mL{FEU}"] = "ug/mL{FEU}";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/d"] = "[IU]/d";
+    ResearchElementDefinitionUnitOfMeasure["[dye'U]"] = "[dye'U]";
+    ResearchElementDefinitionUnitOfMeasure["Eq/mL"] = "eq/mL";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/dL"] = "pmol/dL";
+    ResearchElementDefinitionUnitOfMeasure["Bd"] = "Bd";
+    ResearchElementDefinitionUnitOfMeasure["MU/g"] = "mU/g";
+    ResearchElementDefinitionUnitOfMeasure["[hd_i]"] = "[hd_i]";
+    ResearchElementDefinitionUnitOfMeasure["{mm/dd/yyyy}"] = "{mm/dd/yyyy}";
+    ResearchElementDefinitionUnitOfMeasure["[pk_br]"] = "[pk_br]";
+    ResearchElementDefinitionUnitOfMeasure["{# of informative markers}"] = "{# of informative markers}";
+    ResearchElementDefinitionUnitOfMeasure["Fg"] = "fg";
+    ResearchElementDefinitionUnitOfMeasure["Ug/kg/(8.h)"] = "ug/kg/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["MA"] = "mA";
+    ResearchElementDefinitionUnitOfMeasure["Umol/mg{Cre}"] = "umol/mg{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol{1/2cys}/mg{protein}"] = "nmol{1/2cys}/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["/10*12"] = "/10*12";
+    ResearchElementDefinitionUnitOfMeasure["MU/g{protein}"] = "mU/g{protein}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/dL{RBCs}"] = "mg/dL{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["[twp]"] = "[twp]";
+    ResearchElementDefinitionUnitOfMeasure["[TCID_50]"] = "[TCID_50]";
+    ResearchElementDefinitionUnitOfMeasure["[lb_ap]"] = "[lb_ap]";
+    ResearchElementDefinitionUnitOfMeasure["{2 or 3 times}/d"] = "{2 or 3 times}/d";
+    ResearchElementDefinitionUnitOfMeasure["Osm"] = "osm";
+    ResearchElementDefinitionUnitOfMeasure["G/(3.d)"] = "g/(3.d)";
+    ResearchElementDefinitionUnitOfMeasure["/100{WBCs}"] = "/100{WBCs}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/umol{creat}"] = "umol/umol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Cm2"] = "cm2";
+    ResearchElementDefinitionUnitOfMeasure["U/mmol{creat}"] = "U/mmol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["G/(100.g)"] = "g/(100.g)";
+    ResearchElementDefinitionUnitOfMeasure["Umol/(2.h)"] = "umol/(2.h)";
+    ResearchElementDefinitionUnitOfMeasure["G/kg/min"] = "g/kg/min";
+    ResearchElementDefinitionUnitOfMeasure["Nm/s/L"] = "nm/s/L";
+    ResearchElementDefinitionUnitOfMeasure["Ng/h"] = "ng/h";
+    ResearchElementDefinitionUnitOfMeasure["G/g{creat}"] = "g/g{creat}";
+    ResearchElementDefinitionUnitOfMeasure["{EIA'U}"] = "{EIA'U}";
+    ResearchElementDefinitionUnitOfMeasure["{Markers}"] = "{Markers}";
+    ResearchElementDefinitionUnitOfMeasure["{Drinks}/d"] = "{Drinks}/d";
+    ResearchElementDefinitionUnitOfMeasure["{Log_IU}"] = "{Log_IU}";
+    ResearchElementDefinitionUnitOfMeasure["{CH100'U}"] = "{CH100'U}";
+    ResearchElementDefinitionUnitOfMeasure["ML/({h'b}.m2)"] = "mL/({h'b}.m2)";
+    ResearchElementDefinitionUnitOfMeasure["[iU]/g"] = "[iU]/g";
+    ResearchElementDefinitionUnitOfMeasure["L/(24.h)"] = "L/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["G/cm2"] = "g/cm2";
+    ResearchElementDefinitionUnitOfMeasure["Ug/g{dry_tissue}"] = "ug/g{dry_tissue}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mg"] = "nmol/mg";
+    ResearchElementDefinitionUnitOfMeasure["[drp]/s"] = "[drp]/s";
+    ResearchElementDefinitionUnitOfMeasure["%{OfLymphocytes}"] = "%{OfLymphocytes}";
+    ResearchElementDefinitionUnitOfMeasure["{copies}"] = "{copies}";
+    ResearchElementDefinitionUnitOfMeasure["U/kg/h"] = "U/kg/h";
+    ResearchElementDefinitionUnitOfMeasure["UL"] = "uL";
+    ResearchElementDefinitionUnitOfMeasure["[mi_br]"] = "[mi_br]";
+    ResearchElementDefinitionUnitOfMeasure["{clock_time}"] = "{clock_time}";
+    ResearchElementDefinitionUnitOfMeasure["'"] = "'";
+    ResearchElementDefinitionUnitOfMeasure["/m2"] = "/m2";
+    ResearchElementDefinitionUnitOfMeasure["%{Carboxyhemoglobin}"] = "%{Carboxyhemoglobin}";
+    ResearchElementDefinitionUnitOfMeasure["[hp_Q]"] = "[hp_Q]";
+    ResearchElementDefinitionUnitOfMeasure["[c]"] = "[c]";
+    ResearchElementDefinitionUnitOfMeasure["G.m/({hb}.m2)"] = "g.m/({hb}.m2)";
+    ResearchElementDefinitionUnitOfMeasure["[mi_us]"] = "[mi_us]";
+    ResearchElementDefinitionUnitOfMeasure["{RadioactiveT3UptakeRatio}"] = "{RadioactiveT3UptakeRatio}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/g{Hb}"] = "umol/g{Hb}";
+    ResearchElementDefinitionUnitOfMeasure["P"] = "P";
+    ResearchElementDefinitionUnitOfMeasure["CP"] = "cP";
+    ResearchElementDefinitionUnitOfMeasure["[CCID_50]"] = "[CCID_50]";
+    ResearchElementDefinitionUnitOfMeasure["{IfaTiter}"] = "{IfaTiter}";
+    ResearchElementDefinitionUnitOfMeasure["[Amb'a'1'U]"] = "[Amb'a'1'U]";
+    ResearchElementDefinitionUnitOfMeasure["Mg{Phenylketones}/dL"] = "mg{Phenylketones}/dL";
+    ResearchElementDefinitionUnitOfMeasure["[gil_us]"] = "[gil_us]";
+    ResearchElementDefinitionUnitOfMeasure["{ImmuneStatusRatio}"] = "{ImmuneStatusRatio}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/L{rbc}"] = "umol/L{rbc}";
+    ResearchElementDefinitionUnitOfMeasure["[ly]"] = "[ly]";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/(12.h)"] = "mmol/(12.h)";
+    ResearchElementDefinitionUnitOfMeasure["Meq/mL"] = "meq/mL";
+    ResearchElementDefinitionUnitOfMeasure["[MPL'U]/mL"] = "[MPL'U]/mL";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/d"] = "mmol/d";
+    ResearchElementDefinitionUnitOfMeasure["Meq/{specimen}"] = "meq/{specimen}";
+    ResearchElementDefinitionUnitOfMeasure["[oz_tr]"] = "[oz_tr]";
+    ResearchElementDefinitionUnitOfMeasure["UV"] = "uV";
+    ResearchElementDefinitionUnitOfMeasure["[k]"] = "[k]";
+    ResearchElementDefinitionUnitOfMeasure["Pg/mL{sLT}"] = "pg/mL{sLT}";
+    ResearchElementDefinitionUnitOfMeasure["{DdTiter}"] = "{DdTiter}";
+    ResearchElementDefinitionUnitOfMeasure["%{Index}"] = "%{Index}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/min/mg{protein}"] = "nmol/min/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["{TmStp}"] = "{TmStp}";
+    ResearchElementDefinitionUnitOfMeasure["DaL/min/m2"] = "daL/min/m2";
+    ResearchElementDefinitionUnitOfMeasure["/g{creat}"] = "/g{creat}";
+    ResearchElementDefinitionUnitOfMeasure["[rlk_us]"] = "[rlk_us]";
+    ResearchElementDefinitionUnitOfMeasure["Ug/(100.g)"] = "ug/(100.g)";
+    ResearchElementDefinitionUnitOfMeasure["KL"] = "kL";
+    ResearchElementDefinitionUnitOfMeasure["{log_copies}/mL"] = "{log_copies}/mL";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6.[iU]"] = "10*6.[iU]";
+    ResearchElementDefinitionUnitOfMeasure["t"] = "t";
+    ResearchElementDefinitionUnitOfMeasure["Mg/{collection}"] = "mg/{collection}";
+    ResearchElementDefinitionUnitOfMeasure["Eq"] = "eq";
+    ResearchElementDefinitionUnitOfMeasure["U/s"] = "U/s";
+    ResearchElementDefinitionUnitOfMeasure["G/(5.h)"] = "g/(5.h)";
+    ResearchElementDefinitionUnitOfMeasure["Us"] = "us";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/L/s"] = "mmol/L/s";
+    ResearchElementDefinitionUnitOfMeasure["Mg/{Volume}"] = "mg/{Volume}";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/(8.h.kg)"] = "mmol/(8.h.kg)";
+    ResearchElementDefinitionUnitOfMeasure["Num10*3{RBCs}"] = "10*3{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["M[Hg]"] = "m[Hg]";
+    ResearchElementDefinitionUnitOfMeasure["NU/mL"] = "nU/mL";
+    ResearchElementDefinitionUnitOfMeasure["[rch_us]"] = "[rch_us]";
+    ResearchElementDefinitionUnitOfMeasure["Kcal/d"] = "kcal/d";
+    ResearchElementDefinitionUnitOfMeasure["%{HemoglobinSaturation}"] = "%{HemoglobinSaturation}";
+    ResearchElementDefinitionUnitOfMeasure["{Elisa'U}/mL"] = "{Elisa'U}/mL";
+    ResearchElementDefinitionUnitOfMeasure["/wk"] = "/wk";
+    ResearchElementDefinitionUnitOfMeasure["Cm/s"] = "cm/s";
+    ResearchElementDefinitionUnitOfMeasure["[pnt_pr]"] = "[pnt_pr]";
+    ResearchElementDefinitionUnitOfMeasure["G/(4.h)"] = "g/(4.h)";
+    ResearchElementDefinitionUnitOfMeasure["{RBC}/uL"] = "{RBC}/uL";
+    ResearchElementDefinitionUnitOfMeasure["[CFU]/mL"] = "[CFU]/mL";
+    ResearchElementDefinitionUnitOfMeasure["V"] = "V";
+    ResearchElementDefinitionUnitOfMeasure["U"] = "U";
+    ResearchElementDefinitionUnitOfMeasure["MU/mmol{creat}"] = "mU/mmol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/{specimen}"] = "mg/{specimen}";
+    ResearchElementDefinitionUnitOfMeasure["Num10.uN.s/cm"] = "10.uN.s/cm";
+    ResearchElementDefinitionUnitOfMeasure["{ThyroxinUptake'U}"] = "{ThyroxinUptake'U}";
+    ResearchElementDefinitionUnitOfMeasure["Ohm"] = "Ohm";
+    ResearchElementDefinitionUnitOfMeasure["Eq/mmol"] = "eq/mmol";
+    ResearchElementDefinitionUnitOfMeasure["[bbl_us]"] = "[bbl_us]";
+    ResearchElementDefinitionUnitOfMeasure["D/wk"] = "d/wk";
+    ResearchElementDefinitionUnitOfMeasure["G/g"] = "g/g";
+    ResearchElementDefinitionUnitOfMeasure["{NonspecificOunce}"] = "{NonspecificOunce}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/g{hemoglobin}"] = "umol/g{hemoglobin}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mL/h"] = "nmol/mL/h";
+    ResearchElementDefinitionUnitOfMeasure["Umol/10*6{RBC}"] = "umol/10*6{RBC}";
+    ResearchElementDefinitionUnitOfMeasure["%{Cound}"] = "%{Cound}";
+    ResearchElementDefinitionUnitOfMeasure["Meq"] = "meq";
+    ResearchElementDefinitionUnitOfMeasure["ML{fetal_RBCs}"] = "mL{fetal_RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["[ch_us]"] = "[ch_us]";
+    ResearchElementDefinitionUnitOfMeasure["{OpticalDensityRatio}"] = "{OpticalDensityRatio}";
+    ResearchElementDefinitionUnitOfMeasure["G/cm3"] = "g/cm3";
+    ResearchElementDefinitionUnitOfMeasure["{beats}/min"] = "{beats}/min";
+    ResearchElementDefinitionUnitOfMeasure["Bi"] = "Bi";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/dL"] = "[IU]/dL";
+    ResearchElementDefinitionUnitOfMeasure["G/h/m2"] = "g/h/m2";
+    ResearchElementDefinitionUnitOfMeasure["Umol/g"] = "umol/g";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/kg"] = "mmol/kg";
+    ResearchElementDefinitionUnitOfMeasure["Cm3"] = "cm3";
+    ResearchElementDefinitionUnitOfMeasure["ML/L"] = "mL/L";
+    ResearchElementDefinitionUnitOfMeasure["[mclg'U]"] = "[mclg'U]";
+    ResearchElementDefinitionUnitOfMeasure["Ug/L{RBCs}"] = "ug/L{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["Cd"] = "cd";
+    ResearchElementDefinitionUnitOfMeasure["{Ehrlich'U}/d"] = "{Ehrlich'U}/d";
+    ResearchElementDefinitionUnitOfMeasure["[in_br]"] = "[in_br]";
+    ResearchElementDefinitionUnitOfMeasure["{AHF'U}"] = "{AHF'U}";
+    ResearchElementDefinitionUnitOfMeasure["[lton_av]"] = "[lton_av]";
+    ResearchElementDefinitionUnitOfMeasure["[bf_i]"] = "[bf_i]";
+    ResearchElementDefinitionUnitOfMeasure["/10*4{RBCs}"] = "/10*4{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/(18.h)"] = "mg/(18.h)";
+    ResearchElementDefinitionUnitOfMeasure["Min/d"] = "min/d";
+    ResearchElementDefinitionUnitOfMeasure["[iU]/kg"] = "[iU]/kg";
+    ResearchElementDefinitionUnitOfMeasure["{PackYears}"] = "{PackYears}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/mol{Cre}"] = "umol/mol{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/d/(173.10*Num2.m2)"] = "mg/d/(173.10*-2.m2)";
+    ResearchElementDefinitionUnitOfMeasure["[tb'U]"] = "[tb'U]";
+    ResearchElementDefinitionUnitOfMeasure["Dm2/s2"] = "dm2/s2";
+    ResearchElementDefinitionUnitOfMeasure["U/10*10"] = "U/10*10";
+    ResearchElementDefinitionUnitOfMeasure["b"] = "b";
+    ResearchElementDefinitionUnitOfMeasure["ML/(10.h)"] = "mL/(10.h)";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/g"] = "mmol/g";
+    ResearchElementDefinitionUnitOfMeasure["Ng/m2"] = "ng/m2";
+    ResearchElementDefinitionUnitOfMeasure["Umol/mg{creat}"] = "umol/mg{creat}";
+    ResearchElementDefinitionUnitOfMeasure["/{OIF}"] = "/{OIF}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/L/s"] = "nmol/L/s";
+    ResearchElementDefinitionUnitOfMeasure["[sft_i]"] = "[sft_i]";
+    ResearchElementDefinitionUnitOfMeasure["/mL"] = "/mL";
+    ResearchElementDefinitionUnitOfMeasure["%{ofBacteria}"] = "%{ofBacteria}";
+    ResearchElementDefinitionUnitOfMeasure["[min_us]"] = "[min_us]";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6"] = "10*6";
+    ResearchElementDefinitionUnitOfMeasure["/mo"] = "/mo";
+    ResearchElementDefinitionUnitOfMeasure["Dyn.s/(cm.m2)"] = "dyn.s/(cm.m2)";
+    ResearchElementDefinitionUnitOfMeasure["/100{WBC}"] = "/100{WBC}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/[sft_i]"] = "ug/[sft_i]";
+    ResearchElementDefinitionUnitOfMeasure["{CGG}"] = "{CGG}";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/g{Hb}"] = "[IU]/g{Hb}";
+    ResearchElementDefinitionUnitOfMeasure["Num10*Num6{Immunofluorescence'U}"] = "10*-6{Immunofluorescence'U}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/10*6{RBCs}"] = "ng/10*6{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["[acr_br]"] = "[acr_br]";
+    ResearchElementDefinitionUnitOfMeasure["Bit_s"] = "bit_s";
+    ResearchElementDefinitionUnitOfMeasure["MPa"] = "mPa";
+    ResearchElementDefinitionUnitOfMeasure["{StimulatingIndex}"] = "{StimulatingIndex}";
+    ResearchElementDefinitionUnitOfMeasure["[arb'U]/mL"] = "[arb'U]/mL";
+    ResearchElementDefinitionUnitOfMeasure["[knk'U]"] = "[knk'U]";
+    ResearchElementDefinitionUnitOfMeasure["Cel"] = "Cel";
+    ResearchElementDefinitionUnitOfMeasure["Pg/mm"] = "pg/mm";
+    ResearchElementDefinitionUnitOfMeasure["HL"] = "hL";
+    ResearchElementDefinitionUnitOfMeasure["UU/mL"] = "uU/mL";
+    ResearchElementDefinitionUnitOfMeasure["Meq/(24.h)"] = "meq/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["Mg/(8.h)"] = "mg/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["{Percentile}"] = "{Percentile}";
+    ResearchElementDefinitionUnitOfMeasure["{EhrlichU}/dL"] = "{EhrlichU}/dL";
+    ResearchElementDefinitionUnitOfMeasure["%{positive}"] = "%{positive}";
+    ResearchElementDefinitionUnitOfMeasure["{Absorbance'U}"] = "{Absorbance'U}";
+    ResearchElementDefinitionUnitOfMeasure["[hp_C]"] = "[hp_C]";
+    ResearchElementDefinitionUnitOfMeasure["G/(kg.min)"] = "g/(kg.min)";
+    ResearchElementDefinitionUnitOfMeasure["{Once}/d"] = "{Once}/d";
+    ResearchElementDefinitionUnitOfMeasure["{IgAPhospholipid'U}"] = "{IgAPhospholipid'U}";
+    ResearchElementDefinitionUnitOfMeasure["{StandardIgM'U}"] = "{StandardIgM'U}";
+    ResearchElementDefinitionUnitOfMeasure["G/(8.kg.h)"] = "g/(8.kg.h)";
+    ResearchElementDefinitionUnitOfMeasure["Meq/kg/min"] = "meq/kg/min";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/h/mg{Hb}"] = "mmol/h/mg{Hb}";
+    ResearchElementDefinitionUnitOfMeasure["K/W"] = "K/W";
+    ResearchElementDefinitionUnitOfMeasure["Mg/(72.h)"] = "mg/(72.h)";
+    ResearchElementDefinitionUnitOfMeasure["[FFU]"] = "[FFU]";
+    ResearchElementDefinitionUnitOfMeasure["[arb'U]"] = "[arb'U]";
+    ResearchElementDefinitionUnitOfMeasure["Mbar"] = "mbar";
+    ResearchElementDefinitionUnitOfMeasure["U/g{Hgb}"] = "U/g{Hgb}";
+    ResearchElementDefinitionUnitOfMeasure["{minidrop}/min"] = "{minidrop}/min";
+    ResearchElementDefinitionUnitOfMeasure["Meq/g{creat}"] = "meq/g{creat}";
+    ResearchElementDefinitionUnitOfMeasure["{#}/{platelet}"] = "{#}/{platelet}";
+    ResearchElementDefinitionUnitOfMeasure["%{Tot'Hgb}"] = "%{Tot'Hgb}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/mmol"] = "ug/mmol";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mg/h"] = "nmol/mg/h";
+    ResearchElementDefinitionUnitOfMeasure["[ft_i]"] = "[ft_i]";
+    ResearchElementDefinitionUnitOfMeasure["g"] = "g";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/g{creat}"] = "mmol/g{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Num10*4/uL"] = "10*4/uL";
+    ResearchElementDefinitionUnitOfMeasure["MCi"] = "mCi";
+    ResearchElementDefinitionUnitOfMeasure["[arb'U]/L"] = "[arb'U]/L";
+    ResearchElementDefinitionUnitOfMeasure["Mm/min"] = "mm/min";
+    ResearchElementDefinitionUnitOfMeasure["{Capsule}"] = "{Capsule}";
+    ResearchElementDefinitionUnitOfMeasure["{StandardDeviation}"] = "{StandardDeviation}";
+    ResearchElementDefinitionUnitOfMeasure["%{Tot'Cholesterol}"] = "%{Tot'Cholesterol}";
+    ResearchElementDefinitionUnitOfMeasure["{ScoreOf}"] = "{ScoreOf}";
+    ResearchElementDefinitionUnitOfMeasure["%{at_60_min}"] = "%{at_60_min}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/kg"] = "mg/kg";
+    ResearchElementDefinitionUnitOfMeasure["Umol/umol"] = "umol/umol";
+    ResearchElementDefinitionUnitOfMeasure["Meq/d"] = "meq/d";
+    ResearchElementDefinitionUnitOfMeasure["ML/h"] = "mL/h";
+    ResearchElementDefinitionUnitOfMeasure["MV"] = "MV";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6/mm3"] = "10*6/mm3";
+    ResearchElementDefinitionUnitOfMeasure["Mg/min"] = "mg/min";
+    ResearchElementDefinitionUnitOfMeasure["By"] = "By";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/min/mg{hemoglobin}"] = "nmol/min/mg{hemoglobin}";
+    ResearchElementDefinitionUnitOfMeasure["CL"] = "cL";
+    ResearchElementDefinitionUnitOfMeasure["Num10*3.U"] = "10*3.U";
+    ResearchElementDefinitionUnitOfMeasure["l"] = "l";
+    ResearchElementDefinitionUnitOfMeasure["%{Oxygen}"] = "%{Oxygen}";
+    ResearchElementDefinitionUnitOfMeasure["U/g"] = "U/g";
+    ResearchElementDefinitionUnitOfMeasure["{IgMIndex}"] = "{IgMIndex}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/nmol"] = "nmol/nmol";
+    ResearchElementDefinitionUnitOfMeasure["ML/kg/(8.h)"] = "mL/kg/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["[smgy'U]"] = "[smgy'U]";
+    ResearchElementDefinitionUnitOfMeasure["U[IU]"] = "u[IU]";
+    ResearchElementDefinitionUnitOfMeasure["[gr]"] = "[gr]";
+    ResearchElementDefinitionUnitOfMeasure["G/mol{creat}"] = "g/mol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["N"] = "N";
+    ResearchElementDefinitionUnitOfMeasure["{StdDeviation'U}"] = "{StdDeviation'U}";
+    ResearchElementDefinitionUnitOfMeasure["NL"] = "nL";
+    ResearchElementDefinitionUnitOfMeasure["Cm[H2O]/s/m"] = "cm[H2O]/s/m";
+    ResearchElementDefinitionUnitOfMeasure["Nmol{BCE}/L"] = "nmol{BCE}/L";
+    ResearchElementDefinitionUnitOfMeasure["/U"] = "/U";
+    ResearchElementDefinitionUnitOfMeasure["Mol/s"] = "mol/s";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mL/min"] = "nmol/mL/min";
+    ResearchElementDefinitionUnitOfMeasure["Mm/h"] = "mm/h";
+    ResearchElementDefinitionUnitOfMeasure["{s_co_ratio}"] = "{s_co_ratio}";
+    ResearchElementDefinitionUnitOfMeasure["%{Fat}"] = "%{Fat}";
+    ResearchElementDefinitionUnitOfMeasure["{kp_C}"] = "{kp_C}";
+    ResearchElementDefinitionUnitOfMeasure["u"] = "u";
+    ResearchElementDefinitionUnitOfMeasure["{spray}"] = "{spray}";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/L{RBCs}"] = "mmol/L{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["[crd_us]"] = "[crd_us]";
+    ResearchElementDefinitionUnitOfMeasure["Cal_[20]"] = "cal_[20]";
+    ResearchElementDefinitionUnitOfMeasure["{lgCopies}/ml"] = "{lgCopies}/ml";
+    ResearchElementDefinitionUnitOfMeasure["/g{tot'prot}"] = "/g{tot'prot}";
+    ResearchElementDefinitionUnitOfMeasure["[GPL'U]"] = "[GPL'U]";
+    ResearchElementDefinitionUnitOfMeasure["Ug/kg/h"] = "ug/kg/h";
+    ResearchElementDefinitionUnitOfMeasure["Mg/(2.h)"] = "mg/(2.h)";
+    ResearchElementDefinitionUnitOfMeasure["{fraction}"] = "{fraction}";
+    ResearchElementDefinitionUnitOfMeasure["/g{tot'nit}"] = "/g{tot'nit}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/h/mL"] = "nmol/h/mL";
+    ResearchElementDefinitionUnitOfMeasure["{Ct_value}"] = "{Ct_value}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/L"] = "nmol/L";
+    ResearchElementDefinitionUnitOfMeasure["Kcal/(24.h)"] = "kcal/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["Meq/min"] = "meq/min";
+    ResearchElementDefinitionUnitOfMeasure["Umol/dL"] = "umol/dL";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/(24.h)"] = "[IU]/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["[gal_wi]"] = "[gal_wi]";
+    ResearchElementDefinitionUnitOfMeasure["[iU]/g{Hgb}"] = "[iU]/g{Hgb}";
+    ResearchElementDefinitionUnitOfMeasure["Pg/L"] = "pg/L";
+    ResearchElementDefinitionUnitOfMeasure["{molecule}/{platelet}"] = "{molecule}/{platelet}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/min/g{protein}"] = "umol/min/g{protein}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/(24.h)"] = "ug/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["%{deficient}"] = "%{deficient}";
+    ResearchElementDefinitionUnitOfMeasure["A"] = "A";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/kg/(8.h)"] = "mmol/kg/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["[pt_br]"] = "[pt_br]";
+    ResearchElementDefinitionUnitOfMeasure["{clock time}"] = "{clock time}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/g{Cre}"] = "ng/g{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["{OD_unit}"] = "{OD_unit}";
+    ResearchElementDefinitionUnitOfMeasure["{CagRepeat}"] = "{CagRepeat}";
+    ResearchElementDefinitionUnitOfMeasure["%{NormalPooledPlasma}"] = "%{NormalPooledPlasma}";
+    ResearchElementDefinitionUnitOfMeasure["[Btu_59]"] = "[Btu_59]";
+    ResearchElementDefinitionUnitOfMeasure["Mol/d"] = "mol/d";
+    ResearchElementDefinitionUnitOfMeasure["Mg/g"] = "mg/g";
+    ResearchElementDefinitionUnitOfMeasure["Mg/(24.h)"] = "mg/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["Nmol"] = "nmol";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mL"] = "nmol/mL";
+    ResearchElementDefinitionUnitOfMeasure["Ng/(8.h)"] = "ng/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["Ug/g{creat}"] = "ug/g{creat}";
+    ResearchElementDefinitionUnitOfMeasure["{#}/[HPF]"] = "{#}/[HPF]";
+    ResearchElementDefinitionUnitOfMeasure["Mg/g{Cre}"] = "mg/g{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["%{FetalErythrocytes}"] = "%{FetalErythrocytes}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/dL{GF}"] = "nmol/dL{GF}";
+    ResearchElementDefinitionUnitOfMeasure["{Absorbance'U}/mL"] = "{Absorbance'U}/mL";
+    ResearchElementDefinitionUnitOfMeasure["{ratio}"] = "{ratio}";
+    ResearchElementDefinitionUnitOfMeasure["Kg.m/s"] = "kg.m/s";
+    ResearchElementDefinitionUnitOfMeasure["{EIAIndex}"] = "{EIAIndex}";
+    ResearchElementDefinitionUnitOfMeasure["/mm"] = "/mm";
+    ResearchElementDefinitionUnitOfMeasure["{tot}"] = "{tot}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/mL/min"] = "umol/mL/min";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/dL"] = "nmol/dL";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/mg{protein}"] = "pmol/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["%{EosSeen}"] = "%{EosSeen}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/dL"] = "ng/dL";
+    ResearchElementDefinitionUnitOfMeasure["G/mol"] = "g/mol";
+    ResearchElementDefinitionUnitOfMeasure["Ng/mg{creat}"] = "ng/mg{creat}";
+    ResearchElementDefinitionUnitOfMeasure["/g{hgb}"] = "/g{hgb}";
+    ResearchElementDefinitionUnitOfMeasure["Gb"] = "Gb";
+    ResearchElementDefinitionUnitOfMeasure["Umol/h/L"] = "umol/h/L";
+    ResearchElementDefinitionUnitOfMeasure["%{normal_pooled_plasma}"] = "%{normal_pooled_plasma}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/s/L"] = "nmol/s/L";
+    ResearchElementDefinitionUnitOfMeasure["Meq/kg/h"] = "meq/kg/h";
+    ResearchElementDefinitionUnitOfMeasure["Ug/g{Hb}"] = "ug/g{Hb}";
+    ResearchElementDefinitionUnitOfMeasure["/g{tot_nit}"] = "/g{tot_nit}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/min/g"] = "umol/min/g";
+    ResearchElementDefinitionUnitOfMeasure["{EIA_titer}"] = "{EIA_titer}";
+    ResearchElementDefinitionUnitOfMeasure["[kn_br]"] = "[kn_br]";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/d"] = "pmol/d";
+    ResearchElementDefinitionUnitOfMeasure["{tbl}"] = "{tbl}";
+    ResearchElementDefinitionUnitOfMeasure["%{Hb}"] = "%{Hb}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/L/h"] = "umol/L/h";
+    ResearchElementDefinitionUnitOfMeasure["%{loss}"] = "%{loss}";
+    ResearchElementDefinitionUnitOfMeasure["Mol/kg"] = "mol/kg";
+    ResearchElementDefinitionUnitOfMeasure["{Ehrlich_U}/dL"] = "{Ehrlich_U}/dL";
+    ResearchElementDefinitionUnitOfMeasure["G{wet_tissue}"] = "g{wet_tissue}";
+    ResearchElementDefinitionUnitOfMeasure["[sct]"] = "[sct]";
+    ResearchElementDefinitionUnitOfMeasure["Ng/(kg.d)"] = "ng/(kg.d)";
+    ResearchElementDefinitionUnitOfMeasure["{Counts}/min"] = "{Counts}/min";
+    ResearchElementDefinitionUnitOfMeasure["Umol/kg{feces}"] = "umol/kg{feces}";
+    ResearchElementDefinitionUnitOfMeasure["[psi]"] = "[psi]";
+    ResearchElementDefinitionUnitOfMeasure["U/10*12{RBCs}"] = "U/10*12{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["/mmol"] = "/mmol";
+    ResearchElementDefinitionUnitOfMeasure["{SatIndex}"] = "{SatIndex}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/(8.h)"] = "ug/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["G/kg/h"] = "g/kg/h";
+    ResearchElementDefinitionUnitOfMeasure["{saturation}"] = "{saturation}";
+    ResearchElementDefinitionUnitOfMeasure["{CAE'U}"] = "{CAE'U}";
+    ResearchElementDefinitionUnitOfMeasure["[stone_av]"] = "[stone_av]";
+    ResearchElementDefinitionUnitOfMeasure["U/mL{RBCs}"] = "U/mL{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["Num10*9/L"] = "10*9/L";
+    ResearchElementDefinitionUnitOfMeasure["Kcal/h"] = "kcal/h";
+    ResearchElementDefinitionUnitOfMeasure["RAD"] = "RAD";
+    ResearchElementDefinitionUnitOfMeasure["Mosm/L"] = "mosm/L";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/min/mg{protein}"] = "pmol/min/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6/mL"] = "10*6/mL";
+    ResearchElementDefinitionUnitOfMeasure["M3/s"] = "m3/s";
+    ResearchElementDefinitionUnitOfMeasure["Meq/h"] = "meq/h";
+    ResearchElementDefinitionUnitOfMeasure["{M.o.M.}"] = "{M.o.M.}";
+    ResearchElementDefinitionUnitOfMeasure["[pnt]"] = "[pnt]";
+    ResearchElementDefinitionUnitOfMeasure["{MultOfMean}"] = "{MultOfMean}";
+    ResearchElementDefinitionUnitOfMeasure["Kat/kg"] = "kat/kg";
+    ResearchElementDefinitionUnitOfMeasure["%{Normal}"] = "%{Normal}";
+    ResearchElementDefinitionUnitOfMeasure["{RPI'U}"] = "{RPI'U}";
+    ResearchElementDefinitionUnitOfMeasure["{APS'U}"] = "{APS'U}";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/{specimen}"] = "mmol/{specimen}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mol{creat}"] = "nmol/mol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["h"] = "h";
+    ResearchElementDefinitionUnitOfMeasure["/mmol{creat}"] = "/mmol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["{StandardIgA'U}"] = "{StandardIgA'U}";
+    ResearchElementDefinitionUnitOfMeasure["{RelativeViscosity}"] = "{RelativeViscosity}";
+    ResearchElementDefinitionUnitOfMeasure["Pg/mg"] = "pg/mg";
+    ResearchElementDefinitionUnitOfMeasure["U/(10.g){feces}"] = "U/(10.g){feces}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/(8.h.kg)"] = "ng/(8.h.kg)";
+    ResearchElementDefinitionUnitOfMeasure["Lmb"] = "Lmb";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/L"] = "mmol/L";
+    ResearchElementDefinitionUnitOfMeasure["[ppb]"] = "[ppb]";
+    ResearchElementDefinitionUnitOfMeasure["ML/kg/h"] = "mL/kg/h";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/mol"] = "pmol/mol";
+    ResearchElementDefinitionUnitOfMeasure["[CFU]/L"] = "[CFU]/L";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/10*9{RBCs}"] = "[IU]/10*9{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/s"] = "ng/s";
+    ResearchElementDefinitionUnitOfMeasure["[h]"] = "[h]";
+    ResearchElementDefinitionUnitOfMeasure["G/(12.h)"] = "g/(12.h)";
+    ResearchElementDefinitionUnitOfMeasure["{Copies}/uL"] = "{Copies}/uL";
+    ResearchElementDefinitionUnitOfMeasure["Fmol/mg{prot}"] = "fmol/mg{prot}";
+    ResearchElementDefinitionUnitOfMeasure["[pptr]"] = "[pptr]";
+    ResearchElementDefinitionUnitOfMeasure["Ug/dL{RBCs}"] = "ug/dL{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["Atm"] = "atm";
+    ResearchElementDefinitionUnitOfMeasure["{Cell}"] = "{Cell}";
+    ResearchElementDefinitionUnitOfMeasure["Mg/{TotalVolume}"] = "mg/{TotalVolume}";
+    ResearchElementDefinitionUnitOfMeasure["NCi"] = "nCi";
+    ResearchElementDefinitionUnitOfMeasure["[bdsk'U]"] = "[bdsk'U]";
+    ResearchElementDefinitionUnitOfMeasure["Ug/min"] = "ug/min";
+    ResearchElementDefinitionUnitOfMeasure["Num1/min"] = "1/min";
+    ResearchElementDefinitionUnitOfMeasure["Ng/g"] = "ng/g";
+    ResearchElementDefinitionUnitOfMeasure["{Patch}"] = "{Patch}";
+    ResearchElementDefinitionUnitOfMeasure["%{Activity}"] = "%{Activity}";
+    ResearchElementDefinitionUnitOfMeasure["[foz_br]"] = "[foz_br]";
+    ResearchElementDefinitionUnitOfMeasure["A_j"] = "a_j";
+    ResearchElementDefinitionUnitOfMeasure["Ng/g{creat}"] = "ng/g{creat}";
+    ResearchElementDefinitionUnitOfMeasure["{#}/L"] = "{#}/L";
+    ResearchElementDefinitionUnitOfMeasure["Ng/mL"] = "ng/mL";
+    ResearchElementDefinitionUnitOfMeasure["ML/m2"] = "mL/m2";
+    ResearchElementDefinitionUnitOfMeasure["[pied]"] = "[pied]";
+    ResearchElementDefinitionUnitOfMeasure["{Immunity}"] = "{Immunity}";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6.[CFU]/L"] = "10*6.[CFU]/L";
+    ResearchElementDefinitionUnitOfMeasure["D/(7.d)"] = "d/(7.d)";
+    ResearchElementDefinitionUnitOfMeasure["{Relative'U}"] = "{Relative'U}";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/m2"] = "mmol/m2";
+    ResearchElementDefinitionUnitOfMeasure["Mg/mg{cre}"] = "mg/mg{cre}";
+    ResearchElementDefinitionUnitOfMeasure["U/(2.h)"] = "U/(2.h)";
+    ResearchElementDefinitionUnitOfMeasure["Ug/d"] = "ug/d";
+    ResearchElementDefinitionUnitOfMeasure["[ppm]{v/v}"] = "[ppm]{v/v}";
+    ResearchElementDefinitionUnitOfMeasure["REM"] = "REM";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mmol"] = "nmol/mmol";
+    ResearchElementDefinitionUnitOfMeasure["Nmol{BCE}"] = "nmol{BCE}";
+    ResearchElementDefinitionUnitOfMeasure["[gil_br]"] = "[gil_br]";
+    ResearchElementDefinitionUnitOfMeasure["[Lf]"] = "[Lf]";
+    ResearchElementDefinitionUnitOfMeasure["{shift}"] = "{shift}";
+    ResearchElementDefinitionUnitOfMeasure["/10*3{RBCs}"] = "/10*3{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["ML/min/{1.73_m2}"] = "mL/min/{1.73_m2}";
+    ResearchElementDefinitionUnitOfMeasure["Ar"] = "ar";
+    ResearchElementDefinitionUnitOfMeasure["G/(6.h)"] = "g/(6.h)";
+    ResearchElementDefinitionUnitOfMeasure["{MPS'U}/mL"] = "{MPS'U}/mL";
+    ResearchElementDefinitionUnitOfMeasure["G/dL"] = "g/dL";
+    ResearchElementDefinitionUnitOfMeasure["U/(12.h)"] = "U/(12.h)";
+    ResearchElementDefinitionUnitOfMeasure["Kg"] = "kg";
+    ResearchElementDefinitionUnitOfMeasure["%{blocked}"] = "%{blocked}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/(8.h)"] = "umol/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["Num10*9/uL"] = "10*9/uL";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/h/mg{protein}"] = "mmol/h/mg{protein}";
+    ResearchElementDefinitionUnitOfMeasure["%{uptake}"] = "%{uptake}";
+    ResearchElementDefinitionUnitOfMeasure["[pca_pr]"] = "[pca_pr]";
+    ResearchElementDefinitionUnitOfMeasure["%{reference}"] = "%{reference}";
+    ResearchElementDefinitionUnitOfMeasure["Cg"] = "cg";
+    ResearchElementDefinitionUnitOfMeasure["{#}/mL"] = "{#}/mL";
+    ResearchElementDefinitionUnitOfMeasure["{absorbance}"] = "{absorbance}";
+    ResearchElementDefinitionUnitOfMeasure["[sc_ap]"] = "[sc_ap]";
+    ResearchElementDefinitionUnitOfMeasure["ML/min/m2"] = "mL/min/m2";
+    ResearchElementDefinitionUnitOfMeasure["%{Precipitate}"] = "%{Precipitate}";
+    ResearchElementDefinitionUnitOfMeasure["Osm/L"] = "osm/L";
+    ResearchElementDefinitionUnitOfMeasure["Umol/min/g{prot}"] = "umol/min/g{prot}";
+    ResearchElementDefinitionUnitOfMeasure["Ug/m3"] = "ug/m3";
+    ResearchElementDefinitionUnitOfMeasure["{Ehrlich'U}"] = "{Ehrlich'U}";
+    ResearchElementDefinitionUnitOfMeasure["U/L"] = "U/L";
+    ResearchElementDefinitionUnitOfMeasure["/s"] = "/s";
+    ResearchElementDefinitionUnitOfMeasure["[e]"] = "[e]";
+    ResearchElementDefinitionUnitOfMeasure["[fth_i]"] = "[fth_i]";
+    ResearchElementDefinitionUnitOfMeasure["{Globules}/[HPF]"] = "{Globules}/[HPF]";
+    ResearchElementDefinitionUnitOfMeasure["Ng/(24.h)"] = "ng/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["Pc"] = "pc";
+    ResearchElementDefinitionUnitOfMeasure["{InhaledTobaccoUseAmountYears}"] = "{InhaledTobaccoUseAmountYears}";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/mmol{urea}"] = "mmol/mmol{urea}";
+    ResearchElementDefinitionUnitOfMeasure["Sb"] = "sb";
+    ResearchElementDefinitionUnitOfMeasure["%{index}"] = "%{index}";
+    ResearchElementDefinitionUnitOfMeasure["Mm"] = "mm";
+    ResearchElementDefinitionUnitOfMeasure["Num10*6.U"] = "10*6.U";
+    ResearchElementDefinitionUnitOfMeasure["Pmol/mmol"] = "pmol/mmol";
+    ResearchElementDefinitionUnitOfMeasure["[ch_br]"] = "[ch_br]";
+    ResearchElementDefinitionUnitOfMeasure["DaL/min"] = "daL/min";
+    ResearchElementDefinitionUnitOfMeasure["[MET]"] = "[MET]";
+    ResearchElementDefinitionUnitOfMeasure["{activity}"] = "{activity}";
+    ResearchElementDefinitionUnitOfMeasure["[cml_i]"] = "[cml_i]";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/(8.h)"] = "mmol/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["{Lyme_index_value}"] = "{Lyme_index_value}";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/{ejaculate}"] = "mmol/{ejaculate}";
+    ResearchElementDefinitionUnitOfMeasure["{Dilution}"] = "{Dilution}";
+    ResearchElementDefinitionUnitOfMeasure["ML/kg/d"] = "mL/kg/d";
+    ResearchElementDefinitionUnitOfMeasure["Bar"] = "bar";
+    ResearchElementDefinitionUnitOfMeasure["W"] = "W";
+    ResearchElementDefinitionUnitOfMeasure["G/{specimen}"] = "g/{specimen}";
+    ResearchElementDefinitionUnitOfMeasure["[qt_br]"] = "[qt_br]";
+    ResearchElementDefinitionUnitOfMeasure["Ng/mg/h"] = "ng/mg/h";
+    ResearchElementDefinitionUnitOfMeasure["Np"] = "Np";
+    ResearchElementDefinitionUnitOfMeasure["N.s"] = "N.s";
+    ResearchElementDefinitionUnitOfMeasure["[mi_i]"] = "[mi_i]";
+    ResearchElementDefinitionUnitOfMeasure["Umol/L"] = "umol/L";
+    ResearchElementDefinitionUnitOfMeasure["U/(18.h)"] = "U/(18.h)";
+    ResearchElementDefinitionUnitOfMeasure["{cells}/[HPF]"] = "{cells}/[HPF]";
+    ResearchElementDefinitionUnitOfMeasure["%{Excretion}"] = "%{Excretion}";
+    ResearchElementDefinitionUnitOfMeasure["[foz_us]"] = "[foz_us]";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/g{creat}"] = "nmol/g{creat}";
+    ResearchElementDefinitionUnitOfMeasure["{StandardIgG'U}"] = "{StandardIgG'U}";
+    ResearchElementDefinitionUnitOfMeasure["[Btu_60]"] = "[Btu_60]";
+    ResearchElementDefinitionUnitOfMeasure["{InhaledTobaccoUsePacks}/d"] = "{InhaledTobaccoUsePacks}/d";
+    ResearchElementDefinitionUnitOfMeasure["G/h"] = "g/h";
+    ResearchElementDefinitionUnitOfMeasure["Min"] = "min";
+    ResearchElementDefinitionUnitOfMeasure["Pg"] = "pg";
+    ResearchElementDefinitionUnitOfMeasure["{ElisaIndex}"] = "{ElisaIndex}";
+    ResearchElementDefinitionUnitOfMeasure["%{basal_activity}"] = "%{basal_activity}";
+    ResearchElementDefinitionUnitOfMeasure["G{Hb}"] = "g{Hb}";
+    ResearchElementDefinitionUnitOfMeasure["{Zscore}"] = "{Zscore}";
+    ResearchElementDefinitionUnitOfMeasure["Pg/dL"] = "pg/dL";
+    ResearchElementDefinitionUnitOfMeasure["Cal_IT"] = "cal_IT";
+    ResearchElementDefinitionUnitOfMeasure["%{cells}"] = "%{cells}";
+    ResearchElementDefinitionUnitOfMeasure["G/m2"] = "g/m2";
+    ResearchElementDefinitionUnitOfMeasure["%{Conversion}"] = "%{Conversion}";
+    ResearchElementDefinitionUnitOfMeasure["[cft_i]"] = "[cft_i]";
+    ResearchElementDefinitionUnitOfMeasure["Meq/(8.h)"] = "meq/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["%{aggregation}"] = "%{aggregation}";
+    ResearchElementDefinitionUnitOfMeasure["L/min/m2"] = "L/min/m2";
+    ResearchElementDefinitionUnitOfMeasure["%{relative}"] = "%{relative}";
+    ResearchElementDefinitionUnitOfMeasure["{Disintegrations}/min"] = "{Disintegrations}/min";
+    ResearchElementDefinitionUnitOfMeasure["[mil_i]"] = "[mil_i]";
+    ResearchElementDefinitionUnitOfMeasure["Ug/L{DDU}"] = "ug/L{DDU}";
+    ResearchElementDefinitionUnitOfMeasure["{ImmuneComplex'U}"] = "{ImmuneComplex'U}";
+    ResearchElementDefinitionUnitOfMeasure["%{Reactivity}"] = "%{Reactivity}";
+    ResearchElementDefinitionUnitOfMeasure["U{G}"] = "U{G}";
+    ResearchElementDefinitionUnitOfMeasure["[yd_us]"] = "[yd_us]";
+    ResearchElementDefinitionUnitOfMeasure["Umol/(24.h)"] = "umol/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["Ng/kg/min"] = "ng/kg/min";
+    ResearchElementDefinitionUnitOfMeasure["%{activity}"] = "%{activity}";
+    ResearchElementDefinitionUnitOfMeasure["[todd'U]"] = "[todd'U]";
+    ResearchElementDefinitionUnitOfMeasure["Umol/mmol{creat}"] = "umol/mmol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["[HP]"] = "[HP]";
+    ResearchElementDefinitionUnitOfMeasure["{Bowls}/d"] = "{Bowls}/d";
+    ResearchElementDefinitionUnitOfMeasure["D"] = "d";
+    ResearchElementDefinitionUnitOfMeasure["Nkat"] = "nkat";
+    ResearchElementDefinitionUnitOfMeasure["[oz_ap]"] = "[oz_ap]";
+    ResearchElementDefinitionUnitOfMeasure["Meq/(2.h)"] = "meq/(2.h)";
+    ResearchElementDefinitionUnitOfMeasure["{#}/uL"] = "{#}/uL";
+    ResearchElementDefinitionUnitOfMeasure["K[iU]/mL"] = "k[iU]/mL";
+    ResearchElementDefinitionUnitOfMeasure["[pouce]"] = "[pouce]";
+    ResearchElementDefinitionUnitOfMeasure["/kg{body_wt}"] = "/kg{body_wt}";
+    ResearchElementDefinitionUnitOfMeasure["[Cal]"] = "[Cal]";
+    ResearchElementDefinitionUnitOfMeasure["Meq/g{Cre}"] = "meq/g{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["%{risk}"] = "%{risk}";
+    ResearchElementDefinitionUnitOfMeasure["[degF]"] = "[degF]";
+    ResearchElementDefinitionUnitOfMeasure["ML/kg"] = "mL/kg";
+    ResearchElementDefinitionUnitOfMeasure["U/h"] = "U/h";
+    ResearchElementDefinitionUnitOfMeasure["G.m"] = "g.m";
+    ResearchElementDefinitionUnitOfMeasure["MU/g{prot}"] = "mU/g{prot}";
+    ResearchElementDefinitionUnitOfMeasure["M[IU]/L"] = "m[IU]/L";
+    ResearchElementDefinitionUnitOfMeasure["{# of calculi}"] = "{# of calculi}";
+    ResearchElementDefinitionUnitOfMeasure["%{dose}"] = "%{dose}";
+    ResearchElementDefinitionUnitOfMeasure["{TIBC'U}"] = "{TIBC'U}";
+    ResearchElementDefinitionUnitOfMeasure["{relative_saturation}"] = "{relative_saturation}";
+    ResearchElementDefinitionUnitOfMeasure["Kg/min"] = "kg/min";
+    ResearchElementDefinitionUnitOfMeasure["MU/L"] = "mU/L";
+    ResearchElementDefinitionUnitOfMeasure["{Ehrlich'U}/dL"] = "{Ehrlich'U}/dL";
+    ResearchElementDefinitionUnitOfMeasure["[cr_i]"] = "[cr_i]";
+    ResearchElementDefinitionUnitOfMeasure["[beth'U]"] = "[beth'U]";
+    ResearchElementDefinitionUnitOfMeasure["{yyyy}"] = "{yyyy}";
+    ResearchElementDefinitionUnitOfMeasure["[hp_X]"] = "[hp_X]";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/(24.h)"] = "mmol/(24.h)";
+    ResearchElementDefinitionUnitOfMeasure["{Spermatozoa}/mL"] = "{Spermatozoa}/mL";
+    ResearchElementDefinitionUnitOfMeasure["Mbar.s/L"] = "mbar.s/L";
+    ResearchElementDefinitionUnitOfMeasure["Ng/mg{Protein}"] = "ng/mg{Protein}";
+    ResearchElementDefinitionUnitOfMeasure["/100{Spermatozoa}"] = "/100{Spermatozoa}";
+    ResearchElementDefinitionUnitOfMeasure["{EV}"] = "{EV}";
+    ResearchElementDefinitionUnitOfMeasure["MU/mL"] = "mU/mL";
+    ResearchElementDefinitionUnitOfMeasure["Mg/(12.h)"] = "mg/(12.h)";
+    ResearchElementDefinitionUnitOfMeasure["[MET].min/wk"] = "[MET].min/wk";
+    ResearchElementDefinitionUnitOfMeasure["{AspirinReaction'U}"] = "{AspirinReaction'U}";
+    ResearchElementDefinitionUnitOfMeasure["Kg/mol"] = "kg/mol";
+    ResearchElementDefinitionUnitOfMeasure["{cfu}/mL"] = "{cfu}/mL";
+    ResearchElementDefinitionUnitOfMeasure["Kg/m3"] = "kg/m3";
+    ResearchElementDefinitionUnitOfMeasure["Mm2"] = "mm2";
+    ResearchElementDefinitionUnitOfMeasure["Umol/mol{Hb}"] = "umol/mol{Hb}";
+    ResearchElementDefinitionUnitOfMeasure["ML/cm[H2O]"] = "mL/cm[H2O]";
+    ResearchElementDefinitionUnitOfMeasure["{EIA_index}"] = "{EIA_index}";
+    ResearchElementDefinitionUnitOfMeasure["U/d"] = "U/d";
+    ResearchElementDefinitionUnitOfMeasure["Fm"] = "fm";
+    ResearchElementDefinitionUnitOfMeasure["Cal_m"] = "cal_m";
+    ResearchElementDefinitionUnitOfMeasure["KU/L"] = "kU/L";
+    ResearchElementDefinitionUnitOfMeasure["S/{control}"] = "s/{control}";
+    ResearchElementDefinitionUnitOfMeasure["Umol{BCE}/mol"] = "umol{BCE}/mol";
+    ResearchElementDefinitionUnitOfMeasure["{GliadinIndexValue}"] = "{GliadinIndexValue}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/(kg.min)"] = "ng/(kg.min)";
+    ResearchElementDefinitionUnitOfMeasure["{Index_val}"] = "{Index_val}";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/mL"] = "[IU]/mL";
+    ResearchElementDefinitionUnitOfMeasure["Ug/kg/min"] = "ug/kg/min";
+    ResearchElementDefinitionUnitOfMeasure["Deg/s"] = "deg/s";
+    ResearchElementDefinitionUnitOfMeasure["U[IU]/L"] = "u[IU]/L";
+    ResearchElementDefinitionUnitOfMeasure["Mmol/mmol{creat}"] = "mmol/mmol{creat}";
+    ResearchElementDefinitionUnitOfMeasure["Umol/min/g{mucosa}"] = "umol/min/g{mucosa}";
+    ResearchElementDefinitionUnitOfMeasure["{DeltaOpticalDensity}"] = "{DeltaOpticalDensity}";
+    ResearchElementDefinitionUnitOfMeasure["{WeeksDays}"] = "{WeeksDays}";
+    ResearchElementDefinitionUnitOfMeasure["[pH]"] = "[pH]";
+    ResearchElementDefinitionUnitOfMeasure["Dyn"] = "dyn";
+    ResearchElementDefinitionUnitOfMeasure["Ng"] = "ng";
+    ResearchElementDefinitionUnitOfMeasure["%{RBCs}"] = "%{RBCs}";
+    ResearchElementDefinitionUnitOfMeasure["Ng/kg/(8.h)"] = "ng/kg/(8.h)";
+    ResearchElementDefinitionUnitOfMeasure["[IU]/h"] = "[IU]/h";
+    ResearchElementDefinitionUnitOfMeasure["[mesh_i]"] = "[mesh_i]";
+    ResearchElementDefinitionUnitOfMeasure["[lne]"] = "[lne]";
+    ResearchElementDefinitionUnitOfMeasure["Mg/g{feces}"] = "mg/g{feces}";
+    ResearchElementDefinitionUnitOfMeasure["[dr_av]"] = "[dr_av]";
+    ResearchElementDefinitionUnitOfMeasure["{ActivityCoefficient}"] = "{ActivityCoefficient}";
+    ResearchElementDefinitionUnitOfMeasure["Nmol/mmol{Cre}"] = "nmol/mmol{Cre}";
+    ResearchElementDefinitionUnitOfMeasure["%{excretion}"] = "%{excretion}";
+    ResearchElementDefinitionUnitOfMeasure["L/L"] = "L/L";
+    ResearchElementDefinitionUnitOfMeasure["Num10*3/mL"] = "10*3/mL";
+    ResearchElementDefinitionUnitOfMeasure["PL"] = "pL";
+})(ResearchElementDefinitionUnitOfMeasure = exports.ResearchElementDefinitionUnitOfMeasure || (exports.ResearchElementDefinitionUnitOfMeasure = {}));
+/** draft | active | retired | unknown */
+var ResearchElementDefinitionStatus;
+(function (ResearchElementDefinitionStatus) {
+    ResearchElementDefinitionStatus["Active"] = "active";
+    ResearchElementDefinitionStatus["Draft"] = "draft";
+    ResearchElementDefinitionStatus["Retired"] = "retired";
+    ResearchElementDefinitionStatus["Unknown"] = "unknown";
+})(ResearchElementDefinitionStatus = exports.ResearchElementDefinitionStatus || (exports.ResearchElementDefinitionStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ResearchStudy.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ResearchStudy.d.ts
index 2843c65..068962f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ResearchStudy.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ResearchStudy.d.ts
@@ -9,11 +9,11 @@ import { DomainResource } from "./DomainResource";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A process where a researcher or organization plans and then executes a series of steps intended to increase the field of healthcare-related knowledge.  This includes studies of safety, efficacy, comparative effectiveness and other information about medications, devices, therapies and other interventional and investigative techniques.  A ResearchStudy involves the gathering of information about human or animal subjects. */
 export interface ResearchStudy extends DomainResource {
+    resourceType: 'ResearchStudy';
     /** What this is study doing */
     description?: markdown;
     /** Classifications for the study */
@@ -27,7 +27,7 @@ export interface ResearchStudy extends DomainResource {
     /** Steps followed in executing study */
     protocol?: Array<Reference>;
     /** Researcher who oversees multiple aspects of the study */
-    principalInvestigator?: Reference<"PractitionerRole" | "Practitioner">;
+    principalInvestigator?: Reference<'PractitionerRole' | 'Practitioner'>;
     _status?: Element;
     /** n-a | early-phase-1 | phase-1 | phase-1-phase-2 | phase-2 | phase-2-phase-3 | phase-3 | phase-4 */
     phase?: CodeableConcept;
@@ -41,7 +41,7 @@ export interface ResearchStudy extends DomainResource {
     /** Used to search for the study */
     keyword?: Array<CodeableConcept>;
     /** active | administratively-completed | approved | closed-to-accrual | closed-to-accrual-and-intervention | completed | disapproved | in-review | temporarily-closed-to-accrual | temporarily-closed-to-accrual-and-intervention | withdrawn */
-    status: code;
+    status: `${ResearchStudyStatus}`;
     /** Condition being studied */
     condition?: Array<CodeableConcept>;
     /** Business Identifier for study */
@@ -64,7 +64,7 @@ export interface ResearchStudy extends DomainResource {
     /** Contact details for the study */
     contact?: Array<ContactDetail>;
     /** Organization that initiates and is legally responsible for the study */
-    sponsor?: Reference<"Organization">;
+    sponsor?: Reference<'Organization'>;
 }
 /** Defined path through the study for a subject */
 export interface ResearchStudyArm extends BackboneElement {
@@ -77,6 +77,20 @@ export interface ResearchStudyArm extends BackboneElement {
     description?: string;
     _description?: Element;
 }
+/** active | administratively-completed | approved | closed-to-accrual | closed-to-accrual-and-intervention | completed | disapproved | in-review | temporarily-closed-to-accrual | temporarily-closed-to-accrual-and-intervention | withdrawn */
+export declare enum ResearchStudyStatus {
+    Active = "active",
+    ClosedToAccrual = "closed-to-accrual",
+    Approved = "approved",
+    AdministrativelyCompleted = "administratively-completed",
+    Withdrawn = "withdrawn",
+    TemporarilyClosedToAccrualAndIntervention = "temporarily-closed-to-accrual-and-intervention",
+    TemporarilyClosedToAccrual = "temporarily-closed-to-accrual",
+    Disapproved = "disapproved",
+    Completed = "completed",
+    ClosedToAccrualAndIntervention = "closed-to-accrual-and-intervention",
+    InReview = "in-review"
+}
 /** A goal for the study */
 export interface ResearchStudyObjective extends BackboneElement {
     /** Label for the objective */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ResearchStudy.js b/vendor/r4/types/hl7-fhir-r4-core/ResearchStudy.js
index c8ad2e5..2ab4e79 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ResearchStudy.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ResearchStudy.js
@@ -1,2 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResearchStudyStatus = void 0;
+/** active | administratively-completed | approved | closed-to-accrual | closed-to-accrual-and-intervention | completed | disapproved | in-review | temporarily-closed-to-accrual | temporarily-closed-to-accrual-and-intervention | withdrawn */
+var ResearchStudyStatus;
+(function (ResearchStudyStatus) {
+    ResearchStudyStatus["Active"] = "active";
+    ResearchStudyStatus["ClosedToAccrual"] = "closed-to-accrual";
+    ResearchStudyStatus["Approved"] = "approved";
+    ResearchStudyStatus["AdministrativelyCompleted"] = "administratively-completed";
+    ResearchStudyStatus["Withdrawn"] = "withdrawn";
+    ResearchStudyStatus["TemporarilyClosedToAccrualAndIntervention"] = "temporarily-closed-to-accrual-and-intervention";
+    ResearchStudyStatus["TemporarilyClosedToAccrual"] = "temporarily-closed-to-accrual";
+    ResearchStudyStatus["Disapproved"] = "disapproved";
+    ResearchStudyStatus["Completed"] = "completed";
+    ResearchStudyStatus["ClosedToAccrualAndIntervention"] = "closed-to-accrual-and-intervention";
+    ResearchStudyStatus["InReview"] = "in-review";
+})(ResearchStudyStatus = exports.ResearchStudyStatus || (exports.ResearchStudyStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ResearchSubject.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ResearchSubject.d.ts
index 27437a9..dd72ba5 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ResearchSubject.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ResearchSubject.d.ts
@@ -4,27 +4,43 @@ import { Period } from "./Period";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** A physical entity which is the primary unit of operational and/or administrative interest in a study. */
 export interface ResearchSubject extends DomainResource {
+    resourceType: 'ResearchSubject';
     /** Study subject is part of */
-    study: Reference<"ResearchStudy">;
+    study: Reference<'ResearchStudy'>;
     _status?: Element;
     _assignedArm?: Element;
     /** Agreement to participate in study */
-    consent?: Reference<"Consent">;
+    consent?: Reference<'Consent'>;
     /** What path should be followed */
     assignedArm?: string;
     /** candidate | eligible | follow-up | ineligible | not-registered | off-study | on-study | on-study-intervention | on-study-observation | pending-on-study | potential-candidate | screening | withdrawn */
-    status: code;
+    status: `${ResearchSubjectStatus}`;
     /** What path was followed */
     actualArm?: string;
     /** Business Identifier for research subject in a study */
     identifier?: Array<Identifier>;
     _actualArm?: Element;
     /** Who is part of study */
-    individual: Reference<"Patient">;
+    individual: Reference<'Patient'>;
     /** Start and end of participation */
     period?: Period;
 }
+/** candidate | eligible | follow-up | ineligible | not-registered | off-study | on-study | on-study-intervention | on-study-observation | pending-on-study | potential-candidate | screening | withdrawn */
+export declare enum ResearchSubjectStatus {
+    Candidate = "candidate",
+    NotRegistered = "not-registered",
+    Screening = "screening",
+    FollowUp = "follow-up",
+    OnStudyIntervention = "on-study-intervention",
+    Eligible = "eligible",
+    OffStudy = "off-study",
+    Withdrawn = "withdrawn",
+    OnStudyObservation = "on-study-observation",
+    PotentialCandidate = "potential-candidate",
+    PendingOnStudy = "pending-on-study",
+    OnStudy = "on-study",
+    Ineligible = "ineligible"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ResearchSubject.js b/vendor/r4/types/hl7-fhir-r4-core/ResearchSubject.js
index c8ad2e5..fe0e13a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ResearchSubject.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ResearchSubject.js
@@ -1,2 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResearchSubjectStatus = void 0;
+/** candidate | eligible | follow-up | ineligible | not-registered | off-study | on-study | on-study-intervention | on-study-observation | pending-on-study | potential-candidate | screening | withdrawn */
+var ResearchSubjectStatus;
+(function (ResearchSubjectStatus) {
+    ResearchSubjectStatus["Candidate"] = "candidate";
+    ResearchSubjectStatus["NotRegistered"] = "not-registered";
+    ResearchSubjectStatus["Screening"] = "screening";
+    ResearchSubjectStatus["FollowUp"] = "follow-up";
+    ResearchSubjectStatus["OnStudyIntervention"] = "on-study-intervention";
+    ResearchSubjectStatus["Eligible"] = "eligible";
+    ResearchSubjectStatus["OffStudy"] = "off-study";
+    ResearchSubjectStatus["Withdrawn"] = "withdrawn";
+    ResearchSubjectStatus["OnStudyObservation"] = "on-study-observation";
+    ResearchSubjectStatus["PotentialCandidate"] = "potential-candidate";
+    ResearchSubjectStatus["PendingOnStudy"] = "pending-on-study";
+    ResearchSubjectStatus["OnStudy"] = "on-study";
+    ResearchSubjectStatus["Ineligible"] = "ineligible";
+})(ResearchSubjectStatus = exports.ResearchSubjectStatus || (exports.ResearchSubjectStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/RiskAssessment.d.ts b/vendor/r4/types/hl7-fhir-r4-core/RiskAssessment.d.ts
index 0e247d4..cc0fade 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/RiskAssessment.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/RiskAssessment.d.ts
@@ -8,17 +8,17 @@ import { Range } from "./Range";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome. */
 export interface RiskAssessment extends DomainResource {
+    resourceType: 'RiskAssessment';
     _mitigation?: Element;
     /** Part of this occurrence */
     parent?: Reference;
     /** Where was assessment performed? */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     /** Outcome predicted */
     prediction?: Array<RiskAssessmentPrediction>;
     /** Evaluation mechanism */
@@ -34,9 +34,9 @@ export interface RiskAssessment extends DomainResource {
     note?: Array<Annotation>;
     occurrencePeriod?: Period;
     /** registered | preliminary | final | amended + */
-    status: code;
+    status: `${RiskAssessmentStatus}`;
     /** Condition assessed */
-    condition?: Reference<"Condition">;
+    condition?: Reference<'Condition'>;
     /** Type of assessment */
     code?: CodeableConcept;
     /** Unique identifier for the assessment */
@@ -45,9 +45,9 @@ export interface RiskAssessment extends DomainResource {
     basedOn?: Reference;
     occurrenceDateTime?: dateTime;
     /** Who/what does assessment apply to? */
-    subject: Reference<"Patient" | "Group">;
+    subject: Reference<'Patient' | 'Group'>;
     /** Who did assessment? */
-    performer?: Reference<"PractitionerRole" | "Device" | "Practitioner">;
+    performer?: Reference<'PractitionerRole' | 'Device' | 'Practitioner'>;
     /** Why the assessment was necessary? */
     reasonReference?: Array<Reference>;
     _occurrenceDateTime?: Element;
@@ -70,3 +70,14 @@ export interface RiskAssessmentPrediction extends BackboneElement {
     probabilityDecimal?: decimal;
     _relativeRisk?: Element;
 }
+/** registered | preliminary | final | amended + */
+export declare enum RiskAssessmentStatus {
+    Amended = "amended",
+    Cancelled = "cancelled",
+    Corrected = "corrected",
+    EnteredInError = "entered-in-error",
+    Final = "final",
+    Preliminary = "preliminary",
+    Registered = "registered",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/RiskAssessment.js b/vendor/r4/types/hl7-fhir-r4-core/RiskAssessment.js
index c8ad2e5..6e64138 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/RiskAssessment.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/RiskAssessment.js
@@ -1,2 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiskAssessmentStatus = void 0;
+/** registered | preliminary | final | amended + */
+var RiskAssessmentStatus;
+(function (RiskAssessmentStatus) {
+    RiskAssessmentStatus["Amended"] = "amended";
+    RiskAssessmentStatus["Cancelled"] = "cancelled";
+    RiskAssessmentStatus["Corrected"] = "corrected";
+    RiskAssessmentStatus["EnteredInError"] = "entered-in-error";
+    RiskAssessmentStatus["Final"] = "final";
+    RiskAssessmentStatus["Preliminary"] = "preliminary";
+    RiskAssessmentStatus["Registered"] = "registered";
+    RiskAssessmentStatus["Unknown"] = "unknown";
+})(RiskAssessmentStatus = exports.RiskAssessmentStatus || (exports.RiskAssessmentStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/RiskEvidenceSynthesis.d.ts b/vendor/r4/types/hl7-fhir-r4-core/RiskEvidenceSynthesis.d.ts
index 5467f99..c95cf58 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/RiskEvidenceSynthesis.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/RiskEvidenceSynthesis.d.ts
@@ -14,12 +14,12 @@ import { date } from "./date";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** The RiskEvidenceSynthesis resource describes the likelihood of an outcome in a population plus exposure state where the risk estimate is derived from a combination of research studies. */
 export interface RiskEvidenceSynthesis extends DomainResource {
+    resourceType: 'RiskEvidenceSynthesis';
     /** Natural language description of the risk evidence synthesis */
     description?: markdown;
     /** Date last changed */
@@ -47,7 +47,7 @@ export interface RiskEvidenceSynthesis extends DomainResource {
     studyType?: CodeableConcept;
     _approvalDate?: Element;
     /** What outcome? */
-    outcome: Reference<"EvidenceVariable">;
+    outcome: Reference<'EvidenceVariable'>;
     /** The category of the EffectEvidenceSynthesis, such as Education, Treatment, Assessment, etc. */
     topic?: Array<CodeableConcept>;
     /** Name for this risk evidence synthesis (human friendly) */
@@ -61,9 +61,9 @@ export interface RiskEvidenceSynthesis extends DomainResource {
     synthesisType?: CodeableConcept;
     _lastReviewDate?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${RiskEvidenceSynthesisStatus}`;
     /** What population? */
-    population: Reference<"EvidenceVariable">;
+    population: Reference<'EvidenceVariable'>;
     _name?: Element;
     /** Canonical identifier for this risk evidence synthesis, represented as a URI (globally unique) */
     url?: uri;
@@ -80,7 +80,7 @@ export interface RiskEvidenceSynthesis extends DomainResource {
     /** Who reviewed the content */
     reviewer?: Array<ContactDetail>;
     /** What exposure? */
-    exposure?: Reference<"EvidenceVariable">;
+    exposure?: Reference<'EvidenceVariable'>;
     /** Business version of the risk evidence synthesis */
     version?: string;
     _version?: Element;
@@ -106,6 +106,13 @@ export interface RiskEvidenceSynthesisSampleSize extends BackboneElement {
     numberOfParticipants?: integer;
     _numberOfParticipants?: Element;
 }
+/** draft | active | retired | unknown */
+export declare enum RiskEvidenceSynthesisStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
 /** A component that contributes to the overall certainty */
 export interface RiskEvidenceSynthesisCertaintySubcomponent extends BackboneElement {
     /** Type of subcomponent of certainty rating */
@@ -138,6 +145,1419 @@ export interface RiskEvidenceSynthesisPrecisionEstimate extends BackboneElement
     to?: decimal;
     _to?: Element;
 }
+/** What unit is the outcome described in? */
+export declare enum RiskEvidenceSynthesisUnitOfMeasure {
+    "Mo_j" = "mo_j",
+    CSt = "cSt",
+    "%{breakdown}" = "%{breakdown}",
+    "{rel_saturation}" = "{rel_saturation}",
+    "Fmol/g" = "fmol/g",
+    "{Pouches}/wk" = "{Pouches}/wk",
+    "Umol/mL" = "umol/mL",
+    "Kg/s" = "kg/s",
+    Bq = "Bq",
+    KPa = "kPa",
+    "Mosm/kg" = "mosm/kg",
+    "Mg/L" = "mg/L",
+    "Meq/kg" = "meq/kg",
+    "Nmol/(24.h)" = "nmol/(24.h)",
+    "U/mol" = "U/mol",
+    T = "T",
+    "K[IU]/mL" = "k[IU]/mL",
+    "B[V]" = "B[V]",
+    "Pmol/g" = "pmol/g",
+    "Num10*5" = "10*5",
+    Cm = "cm",
+    "{WhiteBloodCell}" = "{WhiteBloodCell}",
+    "{MPS'U}" = "{MPS'U}",
+    "Nmol/g{dry_wt}" = "nmol/g{dry_wt}",
+    Gf = "gf",
+    "{MPortionPhospholipids}" = "{M-PortionPhospholipids}",
+    "{titer}" = "{titer}",
+    "/g" = "/g",
+    "{Breaths}/min" = "{Breaths}/min",
+    "KU/mL" = "kU/mL",
+    "[rd_us]" = "[rd_us]",
+    "U{37Cel}/L" = "U{37Cel}/L",
+    "Pmol/H/mg{protein}" = "pmol/H/mg{protein}",
+    "[fth_us]" = "[fth_us]",
+    "Fmol/mg{cyt_prot}" = "fmol/mg{cyt_prot}",
+    "G/(kg.h)" = "g/(kg.h)",
+    "%{vol}" = "%{vol}",
+    "/{entity}" = "/{entity}",
+    "Mol/mol" = "mol/mol",
+    "Umol/h/g" = "umol/h/g",
+    Dm = "dm",
+    "[ston_av]" = "[ston_av]",
+    "G/g{Cre}" = "g/g{Cre}",
+    "%{Inhibition}" = "%{Inhibition}",
+    Mol = "mol",
+    "Pmol/h/mg{prot}" = "pmol/h/mg{prot}",
+    K = "K",
+    "{ComplementActivityEnzyme'U}" = "{ComplementActivityEnzyme'U}",
+    "%{WeightToWeight}" = "%{WeightToWeight}",
+    "%{bacteria}" = "%{bacteria}",
+    "Mg/(8.h.kg)" = "mg/(8.h.kg)",
+    "Cm[H2O]/(s.m)" = "cm[H2O]/(s.m)",
+    "[smi_us]" = "[smi_us]",
+    "Nmol/min" = "nmol/min",
+    "%{Bound}" = "%{Bound}",
+    "G/kg" = "g/kg",
+    Att = "att",
+    "Mg/L{RBCs}" = "mg/L{RBCs}",
+    "ML/(72.h)" = "mL/(72.h)",
+    "G.m/{hb}" = "g.m/{hb}",
+    "Ug/m2" = "ug/m2",
+    "Pmol/umol" = "pmol/umol",
+    "Meq/(kg.d)" = "meq/(kg.d)",
+    "Num10*3{Copies}/mL" = "10*3{Copies}/mL",
+    "Mg/kg/(24.h)" = "mg/kg/(24.h)",
+    "Mm[Hg]" = "mm[Hg]",
+    "Ug/dL{rbc}" = "ug/dL{rbc}",
+    "U/10*6" = "U/10*6",
+    "Ng/d" = "ng/d",
+    "[USP'U]" = "[USP'U]",
+    "Mmol/(2.h)" = "mmol/(2.h)",
+    "Num10.uN.s/(cm.m2)" = "10.uN.s/(cm.m2)",
+    "[in_us]" = "[in_us]",
+    Fmol = "fmol",
+    "Fmol/mg{protein}" = "fmol/mg{protein}",
+    "Nmol/L/mmol{creat}" = "nmol/L/mmol{creat}",
+    "[Btu]" = "[Btu]",
+    "Pmol/{RBC}" = "pmol/{RBC}",
+    "/10*3.{RBCs}" = "/10*3.{RBCs}",
+    "G/mmol{creat}" = "g/mmol{creat}",
+    "{AntibodyResponse'U}" = "{AntibodyResponse'U}",
+    "[IU]/kg" = "[IU]/kg",
+    "U/kg{hemoglobin}" = "U/kg{hemoglobin}",
+    "MU/mg" = "mU/mg",
+    "Cm[H2O]" = "cm[H2O]",
+    AU = "AU",
+    "Pg/{RBC}" = "pg/{RBC}",
+    "%{reactive}" = "%{reactive}",
+    "G/g{globulin}" = "g/g{globulin}",
+    "{cells}" = "{cells}",
+    "%{Live}" = "%{Live}",
+    "[pwt_tr]" = "[pwt_tr]",
+    "[ligne]" = "[ligne]",
+    "{IFA_index}" = "{IFA_index}",
+    "MU/mL/min" = "mU/mL/min",
+    "Num10*" = "10*",
+    "Pmol/min/mg{prot}" = "pmol/min/mg{prot}",
+    "[G]" = "[G]",
+    "ML/(24.h)" = "mL/(24.h)",
+    "[ka'U]" = "[ka'U]",
+    "G/L" = "g/L",
+    "/100" = "/100",
+    "Ng/mL{rbc}" = "ng/mL{rbc}",
+    st = "st",
+    "Umol/mol" = "umol/mol",
+    "Kat/L" = "kat/L",
+    "U/g{hemoglobin}" = "U/g{hemoglobin}",
+    "KU/L{class}" = "kU/L{class}",
+    "Pmol/mg{prot}" = "pmol/mg{prot}",
+    "Nmol/h/mg{protein}" = "nmol/h/mg{protein}",
+    "Num10*3{copies}/mL" = "10*3{copies}/mL",
+    "Mmol/h" = "mmol/h",
+    "[ppth]" = "[ppth]",
+    "{genomes}/mL" = "{genomes}/mL",
+    Mmol = "mmol",
+    Gon = "gon",
+    "Ng/dL/h" = "ng/dL/h",
+    "Mg/mmol" = "mg/mmol",
+    "Mg/mmol{Cre}" = "mg/mmol{Cre}",
+    "/100{neutrophils}" = "/100{neutrophils}",
+    "Mmol/(18.h)" = "mmol/(18.h)",
+    "Mmol/min" = "mmol/min",
+    "{spermatozoa}/mL" = "{spermatozoa}/mL",
+    "Mg/mg{Cre}" = "mg/mg{Cre}",
+    "Ng/kg/h" = "ng/kg/h",
+    "Ug/(kg.h)" = "ug/(kg.h)",
+    "{ToxoplasmaIndexValue}" = "{ToxoplasmaIndexValue}",
+    "/[IU]" = "/[IU]",
+    "/d" = "/d",
+    "Mg/(10.h)" = "mg/(10.h)",
+    "[cin_i]" = "[cin_i]",
+    "[oz_av]" = "[oz_av]",
+    "Ng/10*6" = "ng/10*6",
+    "%{HemoglobinA1C}" = "%{HemoglobinA1C}",
+    "{Ehrlich'U}/mL" = "{Ehrlich'U}/mL",
+    "{Applicator}" = "{Applicator}",
+    Pmol = "pmol",
+    "M[IU]/mL" = "m[IU]/mL",
+    "Mg/g{creat}" = "mg/g{creat}",
+    "U/mL" = "U/mL",
+    "[scwt_av]" = "[scwt_av]",
+    "[cicero]" = "[cicero]",
+    s = "s",
+    "Mmol/(5.h)" = "mmol/(5.h)",
+    "Pmol/h/mg{protein}" = "pmol/h/mg{protein}",
+    "{ElisaU}/mL" = "{ElisaU}/mL",
+    "Num10*12/L" = "10*12/L",
+    "G%" = "g%",
+    "Mol/mL" = "mol/mL",
+    "Meq/dL" = "meq/dL",
+    Lx = "lx",
+    "{Bottle}" = "{Bottle}",
+    "Nmol{ATP}" = "nmol{ATP}",
+    Lm = "lm",
+    "Ng/mL/h" = "ng/mL/h",
+    "Ug/g{Tissue}" = "ug/g{Tissue}",
+    "Umol/dL{GF}" = "umol/dL{GF}",
+    "/kg{body'wt}" = "/kg{body'wt}",
+    "{rbc}" = "{rbc}",
+    "Ug{T4}/dL" = "ug{T4}/dL",
+    "Umol/mmol" = "umol/mmol",
+    "Num10*3/uL" = "10*3/uL",
+    "{Log_copies}/mL" = "{Log_copies}/mL",
+    "Fmol/mg" = "fmol/mg",
+    "Lm/m2" = "lm/m2",
+    "%{blockade}" = "%{blockade}",
+    "Ug/mL{class}" = "ug/mL{class}",
+    "MU/min" = "mU/min",
+    Gy = "Gy",
+    "Num10*3" = "10*3",
+    "/[HPF]" = "/[HPF]",
+    "{M.o.M}" = "{M.o.M}",
+    "Pg/mL" = "pg/mL",
+    "{JDF'U}" = "{JDF'U}",
+    "A_t" = "a_t",
+    "Ug/g{Hgb}" = "ug/g{Hgb}",
+    "[sin_i]" = "[sin_i]",
+    "Pmol/h/mL" = "pmol/h/mL",
+    "U{25Cel}/L" = "U{25Cel}/L",
+    "Num10^" = "10^",
+    "{WBCs}" = "{WBCs}",
+    "{4 times}/d" = "{4 times}/d",
+    Ci = "Ci",
+    "Mg/g{tissue}" = "mg/g{tissue}",
+    "Ug/ng" = "ug/ng",
+    "[IU]/L{37Cel}" = "[IU]/L{37Cel}",
+    Pa = "Pa",
+    "{ERY}/uL" = "{ERY}/uL",
+    "Pmol/umol{creat}" = "pmol/umol{creat}",
+    "{binding_index}" = "{binding_index}",
+    MeV = "MeV",
+    "B[kW]" = "B[kW]",
+    "Mg/kg/d" = "mg/kg/d",
+    "/ug" = "/ug",
+    GBq = "GBq",
+    "Ug/(kg.d)" = "ug/(kg.d)",
+    "[tsp_us]" = "[tsp_us]",
+    "Mg/g{dry_tissue}" = "mg/g{dry_tissue}",
+    "/10*3" = "/10*3",
+    UOhm = "uOhm",
+    "ML/(8.h)" = "mL/(8.h)",
+    "/100{spermatozoa}" = "/100{spermatozoa}",
+    "Fmol/mL" = "fmol/mL",
+    "{# of fetuses}" = "{# of fetuses}",
+    "Ug/mL{eqv}" = "ug/mL{eqv}",
+    "{Packs}/d" = "{Packs}/d",
+    "[S]" = "[S]",
+    "G/min" = "g/min",
+    "Nmol/mol" = "nmol/mol",
+    MU = "mU",
+    Ug = "ug",
+    Ml = "ml",
+    "%[slope]" = "%[slope]",
+    "MU/mg{creat}" = "mU/mg{creat}",
+    "G.m/{beat}" = "g.m/{beat}",
+    "Num1/d" = "1/d",
+    "B[mV]" = "B[mV]",
+    MBq = "MBq",
+    UU = "uU",
+    "[PRU]" = "[PRU]",
+    "{Cells}/mL" = "{Cells}/mL",
+    "L/(min.m2)" = "L/(min.m2)",
+    "Ug/L" = "ug/L",
+    "Kg/m2" = "kg/m2",
+    "[smoot]" = "[smoot]",
+    "Ug/dL" = "ug/dL",
+    "[p'diop]" = "[p'diop]",
+    "Nmol/mg{prot}" = "nmol/mg{prot}",
+    "[ppm]" = "[ppm]",
+    "%{Total}" = "%{Total}",
+    "G/(24.h)" = "g/(24.h)",
+    "Num10*Num3{Polarization'U}" = "10*-3{Polarization'U}",
+    Pm = "pm",
+    "Umol/h/mg{protein}" = "umol/h/mg{protein}",
+    "G{total_prot}" = "g{total_prot}",
+    "/10*9" = "/10*9",
+    "/g{wet_tis}" = "/g{wet_tis}",
+    "%{inhibition}" = "%{inhibition}",
+    "/100{cells}" = "/100{cells}",
+    "Nmol/min/mg{prot}" = "nmol/min/mg{prot}",
+    "B[SPL]" = "B[SPL]",
+    "{Events}" = "{Events}",
+    "Ng/kg" = "ng/kg",
+    "[gal_br]" = "[gal_br]",
+    "/a" = "/a",
+    "Nmol/m/mg{prot}" = "nmol/m/mg{prot}",
+    "{#}/[LPF]" = "{#}/[LPF]",
+    "G/{total_weight}" = "g/{total_weight}",
+    "Nmol/mg{protein}" = "nmol/mg{protein}",
+    "[fdr_us]" = "[fdr_us]",
+    "Ug/mg" = "ug/mg",
+    "Ug/{specimen}" = "ug/{specimen}",
+    "U/(24.h)" = "U/(24.h)",
+    "Mmol/mmol" = "mmol/mmol",
+    "Mmol/kg/h" = "mmol/kg/h",
+    "Ug{FEU}/mL" = "ug{FEU}/mL",
+    ML = "mL",
+    "ML/[sin_i]" = "mL/[sin_i]",
+    "Num10*6/(24.h)" = "10*6/(24.h)",
+    "U/min" = "U/min",
+    "ML/d" = "mL/d",
+    "[APL'U]/mL" = "[APL'U]/mL",
+    "''" = "''",
+    "%{0to3Hours}" = "%{0to3Hours}",
+    "[lbf_av]" = "[lbf_av]",
+    "H/wk" = "h/wk",
+    "/10*12{RBCs}" = "/10*12{RBCs}",
+    "/h" = "/h",
+    "%{Hemolysis}" = "%{Hemolysis}",
+    "/kg" = "/kg",
+    "U/g{Hb}" = "U/g{Hb}",
+    "[MPL'U]" = "[MPL'U]",
+    "Mmol/mol{creat}" = "mmol/mol{creat}",
+    "Mg/g{wet_tissue}" = "mg/g{wet_tissue}",
+    "Umol/L{RBCs}" = "umol/L{RBCs}",
+    Rad = "rad",
+    Ueq = "ueq",
+    "Ohm.m" = "Ohm.m",
+    "{OpticalDensityIndex}" = "{OpticalDensityIndex}",
+    "Ng/(kg.h)" = "ng/(kg.h)",
+    "Mmol/kg/min" = "mmol/kg/min",
+    "Num10.L/(min.m2)" = "10.L/(min.m2)",
+    "%{BasalActivity}" = "%{BasalActivity}",
+    "[APL'U]" = "[APL'U]",
+    "[Btu_39]" = "[Btu_39]",
+    "Ng/mg" = "ng/mg",
+    "B[W]" = "B[W]",
+    DL = "dL",
+    "{CGG_repeats}" = "{CGG_repeats}",
+    "U/kg{Hb}" = "U/kg{Hb}",
+    "Mg/(kg.h)" = "mg/(kg.h)",
+    "Num10*9/mL" = "10*9/mL",
+    Nm = "nm",
+    "Ng/L" = "ng/L",
+    "{mutation}" = "{mutation}",
+    EV = "eV",
+    "[drp]/[HPF]" = "[drp]/[HPF]",
+    "%{response}" = "%{response}",
+    "/min" = "/min",
+    "/[LPF]" = "/[LPF]",
+    "[pca]" = "[pca]",
+    "[pk_us]" = "[pk_us]",
+    "{ComplementCH50'U}" = "{ComplementCH50'U}",
+    "Num10*6.[IU]" = "10*6.[IU]",
+    "M/s2" = "m/s2",
+    "{cells}/uL" = "{cells}/uL",
+    "%{WBCs}" = "%{WBCs}",
+    "Meq/g" = "meq/g",
+    "{3 times}/d" = "{3 times}/d",
+    "{GPortionPhospholipids}" = "{G-PortionPhospholipids}",
+    Umol = "umol",
+    "Fmol/L" = "fmol/L",
+    "Umol/mol{creat}" = "umol/mol{creat}",
+    "{Volume}/{Vvolume}" = "{Volume}/{Vvolume}",
+    Wb = "Wb",
+    "Nmol/min/mg{Hb}" = "nmol/min/mg{Hb}",
+    "{ARU}" = "{ARU}",
+    "ML/{beat}" = "mL/{beat}",
+    "{Dose}" = "{Dose}",
+    Ukat = "ukat",
+    Mm3 = "mm3",
+    "{Dalton}" = "{Dalton}",
+    L = "L",
+    "U/g{Cre}" = "U/g{Cre}",
+    "{#}" = "{#}",
+    mv = "mV",
+    "%{binding}" = "%{binding}",
+    "Nmol/mg{prot}/h" = "nmol/mg{prot}/h",
+    Mg = "mg",
+    "%{pooled_plasma}" = "%{pooled_plasma}",
+    "{OpticalDensity}" = "{OpticalDensity}",
+    "Ug/{TotalVolume}" = "ug/{TotalVolume}",
+    "%{NormalControl}" = "%{NormalControl}",
+    "{Log}" = "{Log}",
+    "[m_p]" = "[m_p]",
+    "%/100{WBC}" = "%/100{WBC}",
+    "Mg/{Specimen}" = "mg/{Specimen}",
+    "Kcal/kg/(24.h)" = "kcal/kg/(24.h)",
+    "Ug/mg{Cre}" = "ug/mg{Cre}",
+    "[LPF]" = "[LPF]",
+    M2 = "m2",
+    Num1 = "1",
+    Bit = "bit",
+    "{CPM}" = "{CPM}",
+    "Num10*6/L" = "10*6/L",
+    "Ug/g{DryWeight}" = "ug/g{DryWeight}",
+    "[hp_M]" = "[hp_M]",
+    "/10*6" = "/10*6",
+    "Ng{FEU}/mL" = "ng{FEU}/mL",
+    "{Package}" = "{Package}",
+    "Ueq/mL" = "ueq/mL",
+    "Mg/mmol{creat}" = "mg/mmol{creat}",
+    "Umol/g{creat}" = "umol/g{creat}",
+    "Mol/m3" = "mol/m3",
+    "MU/g{Hgb}" = "mU/g{Hgb}",
+    "Nmol/mmol{creat}" = "nmol/mmol{creat}",
+    "%{loss_AChR}" = "%{loss_AChR}",
+    "Umol/min/L" = "umol/min/L",
+    "Mol/L" = "mol/L",
+    Ky = "Ky",
+    "{Molecule}/{Platelet}" = "{Molecule}/{Platelet}",
+    "Mmol/dL" = "mmol/dL",
+    "Num10*3/L" = "10*3/L",
+    "Pg/mg{creat}" = "pg/mg{creat}",
+    "Meq/L" = "meq/L",
+    "%{hemolysis}" = "%{hemolysis}",
+    "G/(8.h){shift}" = "g/(8.h){shift}",
+    "[lk_br]" = "[lk_br]",
+    "L/s" = "L/s",
+    "L/min" = "L/min",
+    "U/g{creat}" = "U/g{creat}",
+    Mx = "Mx",
+    "%{Negative Control}" = "%{Negative Control}",
+    "NU/{RBC}" = "nU/{RBC}",
+    Erg = "erg",
+    "L/h" = "L/h",
+    "%{TotalProtein}" = "%{TotalProtein}",
+    "K[IU]/L" = "k[IU]/L",
+    "Mg/{Tot'Volume}" = "mg/{Tot'Volume}",
+    "%{abnormal}" = "%{abnormal}",
+    "[in_i'H2O]" = "[in_i'H2O]",
+    Ms = "Ms",
+    "{Tscore}" = "{Tscore}",
+    "Mmol/mol{Cre}" = "mmol/mol{Cre}",
+    "KU/h" = "kU/h",
+    "A/m" = "A/m",
+    "Ug/g{Cre}" = "ug/g{Cre}",
+    "[dr_ap]" = "[dr_ap]",
+    "{HaTiter}" = "{HaTiter}",
+    Kat = "kat",
+    "{copies}/mL" = "{copies}/mL",
+    "ML/min" = "mL/min",
+    "ML/(12.h)" = "mL/(12.h)",
+    "[hnsf'U]" = "[hnsf'U]",
+    "Num10*6/{Specimen}" = "10*6/{Specimen}",
+    "Ng/mg{protein}" = "ng/mg{protein}",
+    "/[iU]" = "/[iU]",
+    Hz = "Hz",
+    "{FIU}" = "{FIU}",
+    "[yd_br]" = "[yd_br]",
+    "{FluorescenceIntensity'U}" = "{FluorescenceIntensity'U}",
+    "{Rubella_virus}" = "{Rubella_virus}",
+    "{P2Y12 Reaction Units}" = "{P2Y12 Reaction Units}",
+    "%{Hemoglobin}" = "%{Hemoglobin}",
+    "[drp]/mL" = "[drp]/mL",
+    "[cyd_i]" = "[cyd_i]",
+    "[fur_us]" = "[fur_us]",
+    FL = "fL",
+    "ML/(4.h)" = "mL/(4.h)",
+    "{# of donor informative markers}" = "{# of donor informative markers}",
+    KV = "kV",
+    "Mg/m3" = "mg/m3",
+    "[pt_us]" = "[pt_us]",
+    "Ueq/L" = "ueq/L",
+    "%{ofAvailable}" = "%{ofAvailable}",
+    "{phenotype}" = "{phenotype}",
+    "[pc_br]" = "[pc_br]",
+    "G/mL" = "g/mL",
+    "[D'ag'U]" = "[D'ag'U]",
+    G = "G",
+    "Mg/kg/(8.h)" = "mg/kg/(8.h)",
+    "[HPF]" = "[HPF]",
+    Ps = "ps",
+    "L/s/s2" = "L/s/s2",
+    "Num10*6.eq/mL" = "10*6.eq/mL",
+    KBq = "kBq",
+    "Mg/d/{1.73_m2}" = "mg/d/{1.73_m2}",
+    "[AU]" = "[AU]",
+    Ao = "Ao",
+    "[drp]/h" = "[drp]/h",
+    "ML/(8.h)/kg" = "mL/(8.h)/kg",
+    "Mg/mg{creat}" = "mg/mg{creat}",
+    "Ug/L/(24.h)" = "ug/L/(24.h)",
+    "ML/mm" = "mL/mm",
+    "Nmol/L{RBCs}" = "nmol/L{RBCs}",
+    "[car_Au]" = "[car_Au]",
+    Dg = "dg",
+    Sr = "sr",
+    "%{normal}" = "%{normal}",
+    "/{oif}" = "/{oif}",
+    "{ElisaValue}" = "{ElisaValue}",
+    "Nmol{BCE}/mmol{creat}" = "nmol{BCE}/mmol{creat}",
+    "Mg/d" = "mg/d",
+    "[Btu_th]" = "[Btu_th]",
+    "[iU]/mL" = "[iU]/mL",
+    "{IndexValue}" = "{IndexValue}",
+    "[GPL'U]/mL" = "[GPL'U]/mL",
+    "{Ct}" = "{Ct}",
+    "{IFA_titer}" = "{IFA_titer}",
+    "Mg/{total_output}" = "mg/{total_output}",
+    "%{lysis}" = "%{lysis}",
+    "Mg/mg" = "mg/mg",
+    "{JuvenileDiabetesFound'U}" = "{JuvenileDiabetesFound'U}",
+    "{Each}" = "{Each}",
+    "[fth_br]" = "[fth_br]",
+    "MU/mmol{RBCs}" = "mU/mmol{RBCs}",
+    "{log_IU}/mL" = "{log_IU}/mL",
+    "Nmol/g{Cre}" = "nmol/g{Cre}",
+    "{Copies}/mL" = "{Copies}/mL",
+    "Cal_[15]" = "cal_[15]",
+    DB = "dB",
+    "[lb_tr]" = "[lb_tr]",
+    "L/d" = "L/d",
+    "[Btu_m]" = "[Btu_m]",
+    J = "J",
+    "MPa.s" = "mPa.s",
+    "[iU]" = "[iU]",
+    "Mmol/kg{H2O}" = "mmol/kg{H2O}",
+    "Mbar/L/s" = "mbar/L/s",
+    "{RubellaVirus}" = "{RubellaVirus}",
+    "Nmol/m/mg{protein}" = "nmol/m/mg{protein}",
+    "Pg/{cell}" = "pg/{cell}",
+    "Mg/wk" = "mg/wk",
+    "Mmol/g{hemoglobin}" = "mmol/g{hemoglobin}",
+    "[IU]/(2.h)" = "[IU]/(2.h)",
+    "{EIATiter}" = "{EIATiter}",
+    "{ISR}" = "{ISR}",
+    "Ng/mL{RBCs}" = "ng/mL{RBCs}",
+    "G/(48.h)" = "g/(48.h)",
+    "G/mg" = "g/mg",
+    "FL/nL" = "fL/nL",
+    "Nmol/g" = "nmol/g",
+    "[mu_0]" = "[mu_0]",
+    "/(12.h)" = "/(12.h)",
+    "[pi].rad/min" = "[pi].rad/min",
+    "Ug/kg" = "ug/kg",
+    "Pmol/min" = "pmol/min",
+    "[IU]/min" = "[IU]/min",
+    Ks = "ks",
+    "Mmol/m" = "mmol/m",
+    Ns = "ns",
+    "Kg{wet'tis}" = "kg{wet'tis}",
+    "Kg/h" = "kg/h",
+    "%{Blockade}" = "%{Blockade}",
+    "{minidrop}/s" = "{minidrop}/s",
+    "G/kg/d" = "g/kg/d",
+    "{KRONU'U}/mL" = "{KRONU'U}/mL",
+    "Mmol/{TotalVolume}" = "mmol/{TotalVolume}",
+    Mo = "mo",
+    "Mmol/(6.h)" = "mmol/(6.h)",
+    "{CAG_repeats}" = "{CAG_repeats}",
+    "J/L" = "J/L",
+    "{IgAAntiphosphatidyleserine'U}" = "{IgAAntiphosphatidyleserine'U}",
+    "[BAU]" = "[BAU]",
+    M = "m",
+    "Meq/(12.h)" = "meq/(12.h)",
+    Gal = "Gal",
+    "[fdr_br]" = "[fdr_br]",
+    "{CPM}/10*3{cell}" = "{CPM}/10*3{cell}",
+    "Nmol/mg{creat}" = "nmol/mg{creat}",
+    "Ug/h" = "ug/h",
+    "{GAA_repeats}" = "{GAA_repeats}",
+    "Ug/g{tissue}" = "ug/g{tissue}",
+    "[lk_us]" = "[lk_us]",
+    "Num10.uN.s/(cm5.m2)" = "10.uN.s/(cm5.m2)",
+    "Ug/{Specimen}" = "ug/{Specimen}",
+    "Mmol/kg/d" = "mmol/kg/d",
+    "{Bead}" = "{Bead}",
+    "G/{total_output}" = "g/{total_output}",
+    "KU/g" = "kU/g",
+    PT = "pT",
+    "/{tot}" = "/{tot}",
+    "Nmol/min/10*6{cells}" = "nmol/min/10*6{cells}",
+    "Kg/(s.m2)" = "kg/(s.m2)",
+    "{cfu}" = "{cfu}",
+    "ML/(kg.min)" = "mL/(kg.min)",
+    "ML/{h'b}" = "mL/{h'b}",
+    "[pi]" = "[pi]",
+    Oe = "Oe",
+    "UL/(2.h)" = "uL/(2.h)",
+    "UU/g" = "uU/g",
+    St = "St",
+    "/g{wet'tis}" = "/g{wet'tis}",
+    "{risk}" = "{risk}",
+    "{INR}" = "{INR}",
+    "Mg/mL" = "mg/mL",
+    "ML/(6.h)" = "mL/(6.h)",
+    "{count}" = "{count}",
+    "[acr_us]" = "[acr_us]",
+    "Ng/mg{prot}" = "ng/mg{prot}",
+    "Num10*6/uL" = "10*6/uL",
+    "{#}/d" = "{#}/d",
+    "{LymeIndexValue}" = "{LymeIndexValue}",
+    Mho = "mho",
+    "{index}" = "{index}",
+    "U/g{protein}" = "U/g{protein}",
+    "{#}/wk" = "{#}/wk",
+    "Umol/m" = "umol/m",
+    Sv = "Sv",
+    "[lb_av]" = "[lb_av]",
+    "Mol/mol{creat}" = "mol/mol{creat}",
+    "[lcwt_av]" = "[lcwt_av]",
+    "/g{tot_prot}" = "/g{tot_prot}",
+    "Ug/kg/d" = "ug/kg/d",
+    "{KRONU'U}/L" = "{KRONU'U}/L",
+    "[iU]/dL" = "[iU]/dL",
+    S = "S",
+    "{IgGAntiphosphatidyleserine'U}" = "{IgGAntiphosphatidyleserine'U}",
+    "Ug/g{hair}" = "ug/g{hair}",
+    "%{baseline}" = "%{baseline}",
+    "{EIA'U}/U" = "{EIA'U}/U",
+    "Umol/g{Cre}" = "umol/g{Cre}",
+    "L.s2/s" = "L.s2/s",
+    "[kn_i]" = "[kn_i]",
+    "G{creat}" = "g{creat}",
+    "[Btu_IT]" = "[Btu_IT]",
+    "Mg{creat}" = "mg{creat}",
+    "Ng/min" = "ng/min",
+    "Ug/mmol{creat}" = "ug/mmol{creat}",
+    "[min_br]" = "[min_br]",
+    "%{SpermMotility}" = "%{SpermMotility}",
+    "[in_i]" = "[in_i]",
+    "{Log_IU}/mL" = "{Log_IU}/mL",
+    "{Ehrlich'U}/100.g" = "{Ehrlich'U}/100.g",
+    "[drp]" = "[drp]",
+    "{Vial}" = "{Vial}",
+    "Mg/dL" = "mg/dL",
+    "Cm[H2O]/L/s" = "cm[H2O]/L/s",
+    "Nmol/umol{creat}" = "nmol/umol{creat}",
+    "{INR'unit}" = "{INR'unit}",
+    "[car_m]" = "[car_m]",
+    "/g{Hb}" = "/g{Hb}",
+    "{#}/min" = "{#}/min",
+    "U/umol" = "U/umol",
+    "{IgGIndex}" = "{IgGIndex}",
+    "ML/(5.h)" = "mL/(5.h)",
+    "{Pill}" = "{Pill}",
+    "[CFU]" = "[CFU]",
+    "{Cans}/wk" = "{Cans}/wk",
+    "[nmi_br]" = "[nmi_br]",
+    "Lm.m2" = "lm.m2",
+    "[nmi_i]" = "[nmi_i]",
+    H = "H",
+    "G/(8.h)" = "g/(8.h)",
+    "/m3" = "/m3",
+    "M2/s" = "m2/s",
+    Deg = "deg",
+    "Mg/(6.h)" = "mg/(6.h)",
+    "[gal_us]" = "[gal_us]",
+    "Cm[Hg]" = "cm[Hg]",
+    "ML/(2.h)" = "mL/(2.h)",
+    "/{Specimen}" = "/{Specimen}",
+    "Nmol/mg{protein}/h" = "nmol/mg{protein}/h",
+    "{CfTiter}" = "{CfTiter}",
+    "Meq/{total_volume}" = "meq/{total_volume}",
+    Mosm = "mosm",
+    "[PNU]" = "[PNU]",
+    Km = "km",
+    "Num10.uN.s/cm2" = "10.uN.s/cm2",
+    "[rd_br]" = "[rd_br]",
+    "%{OfWBCs}" = "%{OfWBCs}",
+    "%{Positive}" = "%{Positive}",
+    "{RecTiter}" = "{RecTiter}",
+    "/10*12{rbc}" = "/10*12{rbc}",
+    "Ug/mg{creat}" = "ug/mg{creat}",
+    "ML/mbar" = "mL/mbar",
+    "U/10" = "U/10",
+    "M[iU]" = "m[iU]",
+    "Umol/kg" = "umol/kg",
+    "H/d" = "h/d",
+    "{Can}" = "{Can}",
+    "Cm2/s" = "cm2/s",
+    "Dyn.s/cm" = "dyn.s/cm",
+    "{Ehrlich'U}/(2.h)" = "{Ehrlich'U}/(2.h)",
+    "Min/wk" = "min/wk",
+    "G/kg/(8.h)" = "g/kg/(8.h)",
+    "/mg" = "/mg",
+    "ML/s" = "mL/s",
+    "%{saturation}" = "%{saturation}",
+    Ph = "ph",
+    "L/kg" = "L/kg",
+    KU = "kU",
+    "{delta_OD}" = "{delta_OD}",
+    Um = "um",
+    "Um/s" = "um/s",
+    "[drp]/min" = "[drp]/min",
+    PA = "pA",
+    "[iU]/L" = "[iU]/L",
+    "[syd_i]" = "[syd_i]",
+    "Umol/mg" = "umol/mg",
+    "%{Uptake}" = "%{Uptake}",
+    "Ug/g" = "ug/g",
+    "{5 times}/d" = "{5 times}/d",
+    "MU/g{Hb}" = "mU/g{Hb}",
+    "Mg/h" = "mg/h",
+    "Num10.L/min" = "10.L/min",
+    "[tbs_us]" = "[tbs_us]",
+    "/mm3" = "/mm3",
+    "A_g" = "a_g",
+    "Umol/g{Hgb}" = "umol/g{Hgb}",
+    "G/g{tissue}" = "g/g{tissue}",
+    "%{total}" = "%{total}",
+    "{score}" = "{score}",
+    "G/mmol" = "g/mmol",
+    "[IU]/L" = "[IU]/L",
+    "Eq/L" = "eq/L",
+    "Meq/(8.h.kg)" = "meq/(8.h.kg)",
+    "Pmol/mL" = "pmol/mL",
+    "ML/kg/min" = "mL/kg/min",
+    "M/s" = "m/s",
+    "Pmol/mmol{creat}" = "pmol/mmol{creat}",
+    "Mo_s" = "mo_s",
+    "%" = "%",
+    Sph = "sph",
+    "G.m/{H.B.}" = "g.m/{H.B.}",
+    Kcal = "kcal",
+    "Mg/m2" = "mg/m2",
+    "{TSI_index}" = "{TSI_index}",
+    "[cup_us]" = "[cup_us]",
+    "N.cm" = "N.cm",
+    "U/10*12" = "U/10*12",
+    "{dilution}" = "{dilution}",
+    "Ug/mL" = "ug/mL",
+    "Mol/kg/s" = "mol/kg/s",
+    "Mg/{total_volume}" = "mg/{total_volume}",
+    "[Ch]" = "[Ch]",
+    "ML/{beat}/m2" = "mL/{beat}/m2",
+    "[IU]" = "[IU]",
+    "{Beats}/min" = "{Beats}/min",
+    "Umol/h" = "umol/h",
+    "{Times}/wk" = "{Times}/wk",
+    "Mm[H2O]" = "mm[H2O]",
+    "Fmol/mg{cytosol_protein}" = "fmol/mg{cytosol_protein}",
+    "%{bound}" = "%{bound}",
+    "[yd_i]" = "[yd_i]",
+    "Mg/kg/min" = "mg/kg/min",
+    R = "R",
+    "{Scoop}" = "{Scoop}",
+    "Ug/g{dry_wt}" = "ug/g{dry_wt}",
+    "{Tine'U}" = "{Tine'U}",
+    "{Elisa_U}/mL" = "{Elisa_U}/mL",
+    UCi = "uCi",
+    "U/mL{RBC}" = "U/mL{RBC}",
+    "[ft_us]" = "[ft_us]",
+    "[bu_br]" = "[bu_br]",
+    "[in_i'Hg]" = "[in_i'Hg]",
+    "Mg/{Hgb}/g" = "mg/{Hgb}/g",
+    "[dqt_us]" = "[dqt_us]",
+    C = "C",
+    "Mg{FEU}/L" = "mg{FEU}/L",
+    "Num10*3.{RBC}" = "10*3.{RBC}",
+    "B[uV]" = "B[uV]",
+    "[m_e]" = "[m_e]",
+    "{#}/a" = "{#}/a",
+    "Mmol/h/mg{prot}" = "mmol/h/mg{prot}",
+    ms = "ms",
+    "{breaths}/min" = "{breaths}/min",
+    "Eq/umol" = "eq/umol",
+    Wk = "wk",
+    "Meq/{Specimen}" = "meq/{Specimen}",
+    "Mmol/{total_vol}" = "mmol/{total_vol}",
+    "%{viable}" = "%{viable}",
+    "Umol/min" = "umol/min",
+    "Num24.h" = "24.h",
+    "[dpt_us]" = "[dpt_us]",
+    "Mmol/mol" = "mmol/mol",
+    "{GPS'U}" = "{GPS'U}",
+    "Meq/m2" = "meq/m2",
+    "U/(1.h)" = "U/(1.h)",
+    "/L" = "/L",
+    "/[arb'U]" = "/[arb'U]",
+    "[eps_0]" = "[eps_0]",
+    "U[IU]/mL" = "u[IU]/mL",
+    "Kcal/[oz_av]" = "kcal/[oz_av]",
+    F = "F",
+    "[ft_us]/[ft_us]" = "[ft_us]/[ft_us]",
+    "/dL" = "/dL",
+    "{STDV}" = "{STDV}",
+    "{ELISA'U}" = "{ELISA'U}",
+    "Cal_th" = "cal_th",
+    "G/d" = "g/d",
+    "U/10*9" = "U/10*9",
+    "MU/mg{Cre}" = "mU/mg{Cre}",
+    Circ = "circ",
+    "Nmol/h/mg{prot}" = "nmol/h/mg{prot}",
+    "[ft_br]" = "[ft_br]",
+    "M[H2O]" = "m[H2O]",
+    "%{Binding}" = "%{Binding}",
+    "/{Entity}" = "/{Entity}",
+    "{HA_titer}" = "{HA_titer}",
+    "G/(72.h)" = "g/(72.h)",
+    "[IU]/mg{creat}" = "[IU]/mg{creat}",
+    "L/(8.h)" = "L/(8.h)",
+    "/uL" = "/uL",
+    "UL/h" = "uL/h",
+    Pkat = "pkat",
+    "{percentile}" = "{percentile}",
+    "Pmol/(24.h)" = "pmol/(24.h)",
+    "Umol/d" = "umol/d",
+    "Mo_g" = "mo_g",
+    "Pmol/L" = "pmol/L",
+    "ML/min/(173.10*Num2.m2)" = "mL/min/(173.10*-2.m2)",
+    "[mil_us]" = "[mil_us]",
+    "{index_val}" = "{index_val}",
+    "{JDF'U}/L" = "{JDF'U}/L",
+    "UU/L" = "uU/L",
+    "[srd_us]" = "[srd_us]",
+    "Mg/kg/h" = "mg/kg/h",
+    "Num10*6/kg" = "10*6/kg",
+    "Mmol/{Tot'Volume}" = "mmol/{Tot'Volume}",
+    "Nmol/h/L" = "nmol/h/L",
+    "[IU]/g" = "[IU]/g",
+    "{Number}" = "{Number}",
+    "Kcal/(8.h)" = "kcal/(8.h)",
+    "MV/s" = "mV/s",
+    "%{residual}" = "%{residual}",
+    "Osm/kg" = "osm/kg",
+    "{KCT'U}" = "{KCT'U}",
+    "{ComplementCH100'U}" = "{ComplementCH100'U}",
+    "{minidrp}" = "{minidrp}",
+    "/10*10" = "/10*10",
+    "Nmol/min/mL" = "nmol/min/mL",
+    "Ng/U" = "ng/U",
+    B = "B",
+    "{IgMAntiphosphatidyleserine'U}" = "{IgMAntiphosphatidyleserine'U}",
+    "%{HumanResponse}" = "%{HumanResponse}",
+    "G/{TotalWeight}" = "g/{TotalWeight}",
+    "%{recovery}" = "%{recovery}",
+    "Nmol/s" = "nmol/s",
+    "MU/mmol{creatinine}" = "mU/mmol{creatinine}",
+    "/g{HGB}" = "/g{HGB}",
+    "U/10*10{cells}" = "U/10*10{cells}",
+    "{Streptozyme'U}" = "{Streptozyme'U}",
+    "%{penetration}" = "%{penetration}",
+    "/cm[H2O]" = "/cm[H2O]",
+    "Nmol/d" = "nmol/d",
+    "{IfaIndex}" = "{IfaIndex}",
+    "G{total_nit}" = "g{total_nit}",
+    "{Cells}/uL" = "{Cells}/uL",
+    a = "a",
+    "U/dL" = "U/dL",
+    "G/kg/(8.h){shift}" = "g/kg/(8.h){shift}",
+    "[IU]/kg/d" = "[IU]/kg/d",
+    "Ug/g{feces}" = "ug/g{feces}",
+    "{Count}" = "{Count}",
+    "Mmol/s/L" = "mmol/s/L",
+    "Num10*8" = "10*8",
+    "{Pan_Bio'U}" = "{Pan_Bio'U}",
+    "[didot]" = "[didot]",
+    "[bu_us]" = "[bu_us]",
+    "Ag/{cell}" = "ag/{cell}",
+    Cal = "cal",
+    "%{Abnormal}" = "%{Abnormal}",
+    "[qt_us]" = "[qt_us]",
+    "ML/dL" = "mL/dL",
+    "{#}/g" = "{#}/g",
+    "[diop]" = "[diop]",
+    "[PFU]" = "[PFU]",
+    "{copies}/ug" = "{copies}/ug",
+    "Kg/L" = "kg/L",
+    Torr = "Torr",
+    "Ug/mL{FEU}" = "ug/mL{FEU}",
+    "[IU]/d" = "[IU]/d",
+    "[dye'U]" = "[dye'U]",
+    "Eq/mL" = "eq/mL",
+    "Pmol/dL" = "pmol/dL",
+    Bd = "Bd",
+    "MU/g" = "mU/g",
+    "[hd_i]" = "[hd_i]",
+    "{mm/dd/yyyy}" = "{mm/dd/yyyy}",
+    "[pk_br]" = "[pk_br]",
+    "{# of informative markers}" = "{# of informative markers}",
+    Fg = "fg",
+    "Ug/kg/(8.h)" = "ug/kg/(8.h)",
+    MA = "mA",
+    "Umol/mg{Cre}" = "umol/mg{Cre}",
+    "Nmol{1/2cys}/mg{protein}" = "nmol{1/2cys}/mg{protein}",
+    "/10*12" = "/10*12",
+    "MU/g{protein}" = "mU/g{protein}",
+    "Mg/dL{RBCs}" = "mg/dL{RBCs}",
+    "[twp]" = "[twp]",
+    "[TCID_50]" = "[TCID_50]",
+    "[lb_ap]" = "[lb_ap]",
+    "{2 or 3 times}/d" = "{2 or 3 times}/d",
+    Osm = "osm",
+    "G/(3.d)" = "g/(3.d)",
+    "/100{WBCs}" = "/100{WBCs}",
+    "Umol/umol{creat}" = "umol/umol{creat}",
+    Cm2 = "cm2",
+    "U/mmol{creat}" = "U/mmol{creat}",
+    "G/(100.g)" = "g/(100.g)",
+    "Umol/(2.h)" = "umol/(2.h)",
+    "G/kg/min" = "g/kg/min",
+    "Nm/s/L" = "nm/s/L",
+    "Ng/h" = "ng/h",
+    "G/g{creat}" = "g/g{creat}",
+    "{EIA'U}" = "{EIA'U}",
+    "{Markers}" = "{Markers}",
+    "{Drinks}/d" = "{Drinks}/d",
+    "{Log_IU}" = "{Log_IU}",
+    "{CH100'U}" = "{CH100'U}",
+    "ML/({h'b}.m2)" = "mL/({h'b}.m2)",
+    "[iU]/g" = "[iU]/g",
+    "L/(24.h)" = "L/(24.h)",
+    "G/cm2" = "g/cm2",
+    "Ug/g{dry_tissue}" = "ug/g{dry_tissue}",
+    "Nmol/mg" = "nmol/mg",
+    "[drp]/s" = "[drp]/s",
+    "%{OfLymphocytes}" = "%{OfLymphocytes}",
+    "{copies}" = "{copies}",
+    "U/kg/h" = "U/kg/h",
+    UL = "uL",
+    "[mi_br]" = "[mi_br]",
+    "{clock_time}" = "{clock_time}",
+    "'" = "'",
+    "/m2" = "/m2",
+    "%{Carboxyhemoglobin}" = "%{Carboxyhemoglobin}",
+    "[hp_Q]" = "[hp_Q]",
+    "[c]" = "[c]",
+    "G.m/({hb}.m2)" = "g.m/({hb}.m2)",
+    "[mi_us]" = "[mi_us]",
+    "{RadioactiveT3UptakeRatio}" = "{RadioactiveT3UptakeRatio}",
+    "Umol/g{Hb}" = "umol/g{Hb}",
+    P = "P",
+    CP = "cP",
+    "[CCID_50]" = "[CCID_50]",
+    "{IfaTiter}" = "{IfaTiter}",
+    "[Amb'a'1'U]" = "[Amb'a'1'U]",
+    "Mg{Phenylketones}/dL" = "mg{Phenylketones}/dL",
+    "[gil_us]" = "[gil_us]",
+    "{ImmuneStatusRatio}" = "{ImmuneStatusRatio}",
+    "Umol/L{rbc}" = "umol/L{rbc}",
+    "[ly]" = "[ly]",
+    "Mmol/(12.h)" = "mmol/(12.h)",
+    "Meq/mL" = "meq/mL",
+    "[MPL'U]/mL" = "[MPL'U]/mL",
+    "Mmol/d" = "mmol/d",
+    "Meq/{specimen}" = "meq/{specimen}",
+    "[oz_tr]" = "[oz_tr]",
+    UV = "uV",
+    "[k]" = "[k]",
+    "Pg/mL{sLT}" = "pg/mL{sLT}",
+    "{DdTiter}" = "{DdTiter}",
+    "%{Index}" = "%{Index}",
+    "Nmol/min/mg{protein}" = "nmol/min/mg{protein}",
+    "{TmStp}" = "{TmStp}",
+    "DaL/min/m2" = "daL/min/m2",
+    "/g{creat}" = "/g{creat}",
+    "[rlk_us]" = "[rlk_us]",
+    "Ug/(100.g)" = "ug/(100.g)",
+    KL = "kL",
+    "{log_copies}/mL" = "{log_copies}/mL",
+    "Num10*6.[iU]" = "10*6.[iU]",
+    t = "t",
+    "Mg/{collection}" = "mg/{collection}",
+    Eq = "eq",
+    "U/s" = "U/s",
+    "G/(5.h)" = "g/(5.h)",
+    Us = "us",
+    "Mmol/L/s" = "mmol/L/s",
+    "Mg/{Volume}" = "mg/{Volume}",
+    "Mmol/(8.h.kg)" = "mmol/(8.h.kg)",
+    "Num10*3{RBCs}" = "10*3{RBCs}",
+    "M[Hg]" = "m[Hg]",
+    "NU/mL" = "nU/mL",
+    "[rch_us]" = "[rch_us]",
+    "Kcal/d" = "kcal/d",
+    "%{HemoglobinSaturation}" = "%{HemoglobinSaturation}",
+    "{Elisa'U}/mL" = "{Elisa'U}/mL",
+    "/wk" = "/wk",
+    "Cm/s" = "cm/s",
+    "[pnt_pr]" = "[pnt_pr]",
+    "G/(4.h)" = "g/(4.h)",
+    "{RBC}/uL" = "{RBC}/uL",
+    "[CFU]/mL" = "[CFU]/mL",
+    V = "V",
+    U = "U",
+    "MU/mmol{creat}" = "mU/mmol{creat}",
+    "Mg/{specimen}" = "mg/{specimen}",
+    "Num10.uN.s/cm" = "10.uN.s/cm",
+    "{ThyroxinUptake'U}" = "{ThyroxinUptake'U}",
+    Ohm = "Ohm",
+    "Eq/mmol" = "eq/mmol",
+    "[bbl_us]" = "[bbl_us]",
+    "D/wk" = "d/wk",
+    "G/g" = "g/g",
+    "{NonspecificOunce}" = "{NonspecificOunce}",
+    "Umol/g{hemoglobin}" = "umol/g{hemoglobin}",
+    "Nmol/mL/h" = "nmol/mL/h",
+    "Umol/10*6{RBC}" = "umol/10*6{RBC}",
+    "%{Cound}" = "%{Cound}",
+    Meq = "meq",
+    "ML{fetal_RBCs}" = "mL{fetal_RBCs}",
+    "[ch_us]" = "[ch_us]",
+    "{OpticalDensityRatio}" = "{OpticalDensityRatio}",
+    "G/cm3" = "g/cm3",
+    "{beats}/min" = "{beats}/min",
+    Bi = "Bi",
+    "[IU]/dL" = "[IU]/dL",
+    "G/h/m2" = "g/h/m2",
+    "Umol/g" = "umol/g",
+    "Mmol/kg" = "mmol/kg",
+    Cm3 = "cm3",
+    "ML/L" = "mL/L",
+    "[mclg'U]" = "[mclg'U]",
+    "Ug/L{RBCs}" = "ug/L{RBCs}",
+    Cd = "cd",
+    "{Ehrlich'U}/d" = "{Ehrlich'U}/d",
+    "[in_br]" = "[in_br]",
+    "{AHF'U}" = "{AHF'U}",
+    "[lton_av]" = "[lton_av]",
+    "[bf_i]" = "[bf_i]",
+    "/10*4{RBCs}" = "/10*4{RBCs}",
+    "Mg/(18.h)" = "mg/(18.h)",
+    "Min/d" = "min/d",
+    "[iU]/kg" = "[iU]/kg",
+    "{PackYears}" = "{PackYears}",
+    "Umol/mol{Cre}" = "umol/mol{Cre}",
+    "Mg/d/(173.10*Num2.m2)" = "mg/d/(173.10*-2.m2)",
+    "[tb'U]" = "[tb'U]",
+    "Dm2/s2" = "dm2/s2",
+    "U/10*10" = "U/10*10",
+    b = "b",
+    "ML/(10.h)" = "mL/(10.h)",
+    "Mmol/g" = "mmol/g",
+    "Ng/m2" = "ng/m2",
+    "Umol/mg{creat}" = "umol/mg{creat}",
+    "/{OIF}" = "/{OIF}",
+    "Nmol/L/s" = "nmol/L/s",
+    "[sft_i]" = "[sft_i]",
+    "/mL" = "/mL",
+    "%{ofBacteria}" = "%{ofBacteria}",
+    "[min_us]" = "[min_us]",
+    "Num10*6" = "10*6",
+    "/mo" = "/mo",
+    "Dyn.s/(cm.m2)" = "dyn.s/(cm.m2)",
+    "/100{WBC}" = "/100{WBC}",
+    "Ug/[sft_i]" = "ug/[sft_i]",
+    "{CGG}" = "{CGG}",
+    "[IU]/g{Hb}" = "[IU]/g{Hb}",
+    "Num10*Num6{Immunofluorescence'U}" = "10*-6{Immunofluorescence'U}",
+    "Ng/10*6{RBCs}" = "ng/10*6{RBCs}",
+    "[acr_br]" = "[acr_br]",
+    "Bit_s" = "bit_s",
+    MPa = "mPa",
+    "{StimulatingIndex}" = "{StimulatingIndex}",
+    "[arb'U]/mL" = "[arb'U]/mL",
+    "[knk'U]" = "[knk'U]",
+    Cel = "Cel",
+    "Pg/mm" = "pg/mm",
+    HL = "hL",
+    "UU/mL" = "uU/mL",
+    "Meq/(24.h)" = "meq/(24.h)",
+    "Mg/(8.h)" = "mg/(8.h)",
+    "{Percentile}" = "{Percentile}",
+    "{EhrlichU}/dL" = "{EhrlichU}/dL",
+    "%{positive}" = "%{positive}",
+    "{Absorbance'U}" = "{Absorbance'U}",
+    "[hp_C]" = "[hp_C]",
+    "G/(kg.min)" = "g/(kg.min)",
+    "{Once}/d" = "{Once}/d",
+    "{IgAPhospholipid'U}" = "{IgAPhospholipid'U}",
+    "{StandardIgM'U}" = "{StandardIgM'U}",
+    "G/(8.kg.h)" = "g/(8.kg.h)",
+    "Meq/kg/min" = "meq/kg/min",
+    "Mmol/h/mg{Hb}" = "mmol/h/mg{Hb}",
+    "K/W" = "K/W",
+    "Mg/(72.h)" = "mg/(72.h)",
+    "[FFU]" = "[FFU]",
+    "[arb'U]" = "[arb'U]",
+    Mbar = "mbar",
+    "U/g{Hgb}" = "U/g{Hgb}",
+    "{minidrop}/min" = "{minidrop}/min",
+    "Meq/g{creat}" = "meq/g{creat}",
+    "{#}/{platelet}" = "{#}/{platelet}",
+    "%{Tot'Hgb}" = "%{Tot'Hgb}",
+    "Ug/mmol" = "ug/mmol",
+    "Nmol/mg/h" = "nmol/mg/h",
+    "[ft_i]" = "[ft_i]",
+    g = "g",
+    "Mmol/g{creat}" = "mmol/g{creat}",
+    "Num10*4/uL" = "10*4/uL",
+    MCi = "mCi",
+    "[arb'U]/L" = "[arb'U]/L",
+    "Mm/min" = "mm/min",
+    "{Capsule}" = "{Capsule}",
+    "{StandardDeviation}" = "{StandardDeviation}",
+    "%{Tot'Cholesterol}" = "%{Tot'Cholesterol}",
+    "{ScoreOf}" = "{ScoreOf}",
+    "%{at_60_min}" = "%{at_60_min}",
+    "Mg/kg" = "mg/kg",
+    "Umol/umol" = "umol/umol",
+    "Meq/d" = "meq/d",
+    "ML/h" = "mL/h",
+    MV = "MV",
+    "Num10*6/mm3" = "10*6/mm3",
+    "Mg/min" = "mg/min",
+    By = "By",
+    "Nmol/min/mg{hemoglobin}" = "nmol/min/mg{hemoglobin}",
+    CL = "cL",
+    "Num10*3.U" = "10*3.U",
+    l = "l",
+    "%{Oxygen}" = "%{Oxygen}",
+    "U/g" = "U/g",
+    "{IgMIndex}" = "{IgMIndex}",
+    "Nmol/nmol" = "nmol/nmol",
+    "ML/kg/(8.h)" = "mL/kg/(8.h)",
+    "[smgy'U]" = "[smgy'U]",
+    "U[IU]" = "u[IU]",
+    "[gr]" = "[gr]",
+    "G/mol{creat}" = "g/mol{creat}",
+    N = "N",
+    "{StdDeviation'U}" = "{StdDeviation'U}",
+    NL = "nL",
+    "Cm[H2O]/s/m" = "cm[H2O]/s/m",
+    "Nmol{BCE}/L" = "nmol{BCE}/L",
+    "/U" = "/U",
+    "Mol/s" = "mol/s",
+    "Nmol/mL/min" = "nmol/mL/min",
+    "Mm/h" = "mm/h",
+    "{s_co_ratio}" = "{s_co_ratio}",
+    "%{Fat}" = "%{Fat}",
+    "{kp_C}" = "{kp_C}",
+    u = "u",
+    "{spray}" = "{spray}",
+    "Mmol/L{RBCs}" = "mmol/L{RBCs}",
+    "[crd_us]" = "[crd_us]",
+    "Cal_[20]" = "cal_[20]",
+    "{lgCopies}/ml" = "{lgCopies}/ml",
+    "/g{tot'prot}" = "/g{tot'prot}",
+    "[GPL'U]" = "[GPL'U]",
+    "Ug/kg/h" = "ug/kg/h",
+    "Mg/(2.h)" = "mg/(2.h)",
+    "{fraction}" = "{fraction}",
+    "/g{tot'nit}" = "/g{tot'nit}",
+    "Nmol/h/mL" = "nmol/h/mL",
+    "{Ct_value}" = "{Ct_value}",
+    "Nmol/L" = "nmol/L",
+    "Kcal/(24.h)" = "kcal/(24.h)",
+    "Meq/min" = "meq/min",
+    "Umol/dL" = "umol/dL",
+    "[IU]/(24.h)" = "[IU]/(24.h)",
+    "[gal_wi]" = "[gal_wi]",
+    "[iU]/g{Hgb}" = "[iU]/g{Hgb}",
+    "Pg/L" = "pg/L",
+    "{molecule}/{platelet}" = "{molecule}/{platelet}",
+    "Umol/min/g{protein}" = "umol/min/g{protein}",
+    "Ug/(24.h)" = "ug/(24.h)",
+    "%{deficient}" = "%{deficient}",
+    A = "A",
+    "Mmol/kg/(8.h)" = "mmol/kg/(8.h)",
+    "[pt_br]" = "[pt_br]",
+    "{clock time}" = "{clock time}",
+    "Ng/g{Cre}" = "ng/g{Cre}",
+    "{OD_unit}" = "{OD_unit}",
+    "{CagRepeat}" = "{CagRepeat}",
+    "%{NormalPooledPlasma}" = "%{NormalPooledPlasma}",
+    "[Btu_59]" = "[Btu_59]",
+    "Mol/d" = "mol/d",
+    "Mg/g" = "mg/g",
+    "Mg/(24.h)" = "mg/(24.h)",
+    Nmol = "nmol",
+    "Nmol/mL" = "nmol/mL",
+    "Ng/(8.h)" = "ng/(8.h)",
+    "Ug/g{creat}" = "ug/g{creat}",
+    "{#}/[HPF]" = "{#}/[HPF]",
+    "Mg/g{Cre}" = "mg/g{Cre}",
+    "%{FetalErythrocytes}" = "%{FetalErythrocytes}",
+    "Nmol/dL{GF}" = "nmol/dL{GF}",
+    "{Absorbance'U}/mL" = "{Absorbance'U}/mL",
+    "{ratio}" = "{ratio}",
+    "Kg.m/s" = "kg.m/s",
+    "{EIAIndex}" = "{EIAIndex}",
+    "/mm" = "/mm",
+    "{tot}" = "{tot}",
+    "Umol/mL/min" = "umol/mL/min",
+    "Nmol/dL" = "nmol/dL",
+    "Pmol/mg{protein}" = "pmol/mg{protein}",
+    "%{EosSeen}" = "%{EosSeen}",
+    "Ng/dL" = "ng/dL",
+    "G/mol" = "g/mol",
+    "Ng/mg{creat}" = "ng/mg{creat}",
+    "/g{hgb}" = "/g{hgb}",
+    Gb = "Gb",
+    "Umol/h/L" = "umol/h/L",
+    "%{normal_pooled_plasma}" = "%{normal_pooled_plasma}",
+    "Nmol/s/L" = "nmol/s/L",
+    "Meq/kg/h" = "meq/kg/h",
+    "Ug/g{Hb}" = "ug/g{Hb}",
+    "/g{tot_nit}" = "/g{tot_nit}",
+    "Umol/min/g" = "umol/min/g",
+    "{EIA_titer}" = "{EIA_titer}",
+    "[kn_br]" = "[kn_br]",
+    "Pmol/d" = "pmol/d",
+    "{tbl}" = "{tbl}",
+    "%{Hb}" = "%{Hb}",
+    "Umol/L/h" = "umol/L/h",
+    "%{loss}" = "%{loss}",
+    "Mol/kg" = "mol/kg",
+    "{Ehrlich_U}/dL" = "{Ehrlich_U}/dL",
+    "G{wet_tissue}" = "g{wet_tissue}",
+    "[sct]" = "[sct]",
+    "Ng/(kg.d)" = "ng/(kg.d)",
+    "{Counts}/min" = "{Counts}/min",
+    "Umol/kg{feces}" = "umol/kg{feces}",
+    "[psi]" = "[psi]",
+    "U/10*12{RBCs}" = "U/10*12{RBCs}",
+    "/mmol" = "/mmol",
+    "{SatIndex}" = "{SatIndex}",
+    "Ug/(8.h)" = "ug/(8.h)",
+    "G/kg/h" = "g/kg/h",
+    "{saturation}" = "{saturation}",
+    "{CAE'U}" = "{CAE'U}",
+    "[stone_av]" = "[stone_av]",
+    "U/mL{RBCs}" = "U/mL{RBCs}",
+    "Num10*9/L" = "10*9/L",
+    "Kcal/h" = "kcal/h",
+    RAD = "RAD",
+    "Mosm/L" = "mosm/L",
+    "Pmol/min/mg{protein}" = "pmol/min/mg{protein}",
+    "Num10*6/mL" = "10*6/mL",
+    "M3/s" = "m3/s",
+    "Meq/h" = "meq/h",
+    "{M.o.M.}" = "{M.o.M.}",
+    "[pnt]" = "[pnt]",
+    "{MultOfMean}" = "{MultOfMean}",
+    "Kat/kg" = "kat/kg",
+    "%{Normal}" = "%{Normal}",
+    "{RPI'U}" = "{RPI'U}",
+    "{APS'U}" = "{APS'U}",
+    "Mmol/{specimen}" = "mmol/{specimen}",
+    "Nmol/mol{creat}" = "nmol/mol{creat}",
+    h = "h",
+    "/mmol{creat}" = "/mmol{creat}",
+    "{StandardIgA'U}" = "{StandardIgA'U}",
+    "{RelativeViscosity}" = "{RelativeViscosity}",
+    "Pg/mg" = "pg/mg",
+    "U/(10.g){feces}" = "U/(10.g){feces}",
+    "Ng/(8.h.kg)" = "ng/(8.h.kg)",
+    Lmb = "Lmb",
+    "Mmol/L" = "mmol/L",
+    "[ppb]" = "[ppb]",
+    "ML/kg/h" = "mL/kg/h",
+    "Pmol/mol" = "pmol/mol",
+    "[CFU]/L" = "[CFU]/L",
+    "[IU]/10*9{RBCs}" = "[IU]/10*9{RBCs}",
+    "Ng/s" = "ng/s",
+    "[h]" = "[h]",
+    "G/(12.h)" = "g/(12.h)",
+    "{Copies}/uL" = "{Copies}/uL",
+    "Fmol/mg{prot}" = "fmol/mg{prot}",
+    "[pptr]" = "[pptr]",
+    "Ug/dL{RBCs}" = "ug/dL{RBCs}",
+    Atm = "atm",
+    "{Cell}" = "{Cell}",
+    "Mg/{TotalVolume}" = "mg/{TotalVolume}",
+    NCi = "nCi",
+    "[bdsk'U]" = "[bdsk'U]",
+    "Ug/min" = "ug/min",
+    "Num1/min" = "1/min",
+    "Ng/g" = "ng/g",
+    "{Patch}" = "{Patch}",
+    "%{Activity}" = "%{Activity}",
+    "[foz_br]" = "[foz_br]",
+    "A_j" = "a_j",
+    "Ng/g{creat}" = "ng/g{creat}",
+    "{#}/L" = "{#}/L",
+    "Ng/mL" = "ng/mL",
+    "ML/m2" = "mL/m2",
+    "[pied]" = "[pied]",
+    "{Immunity}" = "{Immunity}",
+    "Num10*6.[CFU]/L" = "10*6.[CFU]/L",
+    "D/(7.d)" = "d/(7.d)",
+    "{Relative'U}" = "{Relative'U}",
+    "Mmol/m2" = "mmol/m2",
+    "Mg/mg{cre}" = "mg/mg{cre}",
+    "U/(2.h)" = "U/(2.h)",
+    "Ug/d" = "ug/d",
+    "[ppm]{v/v}" = "[ppm]{v/v}",
+    REM = "REM",
+    "Nmol/mmol" = "nmol/mmol",
+    "Nmol{BCE}" = "nmol{BCE}",
+    "[gil_br]" = "[gil_br]",
+    "[Lf]" = "[Lf]",
+    "{shift}" = "{shift}",
+    "/10*3{RBCs}" = "/10*3{RBCs}",
+    "ML/min/{1.73_m2}" = "mL/min/{1.73_m2}",
+    Ar = "ar",
+    "G/(6.h)" = "g/(6.h)",
+    "{MPS'U}/mL" = "{MPS'U}/mL",
+    "G/dL" = "g/dL",
+    "U/(12.h)" = "U/(12.h)",
+    Kg = "kg",
+    "%{blocked}" = "%{blocked}",
+    "Umol/(8.h)" = "umol/(8.h)",
+    "Num10*9/uL" = "10*9/uL",
+    "Mmol/h/mg{protein}" = "mmol/h/mg{protein}",
+    "%{uptake}" = "%{uptake}",
+    "[pca_pr]" = "[pca_pr]",
+    "%{reference}" = "%{reference}",
+    Cg = "cg",
+    "{#}/mL" = "{#}/mL",
+    "{absorbance}" = "{absorbance}",
+    "[sc_ap]" = "[sc_ap]",
+    "ML/min/m2" = "mL/min/m2",
+    "%{Precipitate}" = "%{Precipitate}",
+    "Osm/L" = "osm/L",
+    "Umol/min/g{prot}" = "umol/min/g{prot}",
+    "Ug/m3" = "ug/m3",
+    "{Ehrlich'U}" = "{Ehrlich'U}",
+    "U/L" = "U/L",
+    "/s" = "/s",
+    "[e]" = "[e]",
+    "[fth_i]" = "[fth_i]",
+    "{Globules}/[HPF]" = "{Globules}/[HPF]",
+    "Ng/(24.h)" = "ng/(24.h)",
+    Pc = "pc",
+    "{InhaledTobaccoUseAmountYears}" = "{InhaledTobaccoUseAmountYears}",
+    "Mmol/mmol{urea}" = "mmol/mmol{urea}",
+    Sb = "sb",
+    "%{index}" = "%{index}",
+    Mm = "mm",
+    "Num10*6.U" = "10*6.U",
+    "Pmol/mmol" = "pmol/mmol",
+    "[ch_br]" = "[ch_br]",
+    "DaL/min" = "daL/min",
+    "[MET]" = "[MET]",
+    "{activity}" = "{activity}",
+    "[cml_i]" = "[cml_i]",
+    "Mmol/(8.h)" = "mmol/(8.h)",
+    "{Lyme_index_value}" = "{Lyme_index_value}",
+    "Mmol/{ejaculate}" = "mmol/{ejaculate}",
+    "{Dilution}" = "{Dilution}",
+    "ML/kg/d" = "mL/kg/d",
+    Bar = "bar",
+    W = "W",
+    "G/{specimen}" = "g/{specimen}",
+    "[qt_br]" = "[qt_br]",
+    "Ng/mg/h" = "ng/mg/h",
+    Np = "Np",
+    "N.s" = "N.s",
+    "[mi_i]" = "[mi_i]",
+    "Umol/L" = "umol/L",
+    "U/(18.h)" = "U/(18.h)",
+    "{cells}/[HPF]" = "{cells}/[HPF]",
+    "%{Excretion}" = "%{Excretion}",
+    "[foz_us]" = "[foz_us]",
+    "Nmol/g{creat}" = "nmol/g{creat}",
+    "{StandardIgG'U}" = "{StandardIgG'U}",
+    "[Btu_60]" = "[Btu_60]",
+    "{InhaledTobaccoUsePacks}/d" = "{InhaledTobaccoUsePacks}/d",
+    "G/h" = "g/h",
+    Min = "min",
+    Pg = "pg",
+    "{ElisaIndex}" = "{ElisaIndex}",
+    "%{basal_activity}" = "%{basal_activity}",
+    "G{Hb}" = "g{Hb}",
+    "{Zscore}" = "{Zscore}",
+    "Pg/dL" = "pg/dL",
+    "Cal_IT" = "cal_IT",
+    "%{cells}" = "%{cells}",
+    "G/m2" = "g/m2",
+    "%{Conversion}" = "%{Conversion}",
+    "[cft_i]" = "[cft_i]",
+    "Meq/(8.h)" = "meq/(8.h)",
+    "%{aggregation}" = "%{aggregation}",
+    "L/min/m2" = "L/min/m2",
+    "%{relative}" = "%{relative}",
+    "{Disintegrations}/min" = "{Disintegrations}/min",
+    "[mil_i]" = "[mil_i]",
+    "Ug/L{DDU}" = "ug/L{DDU}",
+    "{ImmuneComplex'U}" = "{ImmuneComplex'U}",
+    "%{Reactivity}" = "%{Reactivity}",
+    "U{G}" = "U{G}",
+    "[yd_us]" = "[yd_us]",
+    "Umol/(24.h)" = "umol/(24.h)",
+    "Ng/kg/min" = "ng/kg/min",
+    "%{activity}" = "%{activity}",
+    "[todd'U]" = "[todd'U]",
+    "Umol/mmol{creat}" = "umol/mmol{creat}",
+    "[HP]" = "[HP]",
+    "{Bowls}/d" = "{Bowls}/d",
+    D = "d",
+    Nkat = "nkat",
+    "[oz_ap]" = "[oz_ap]",
+    "Meq/(2.h)" = "meq/(2.h)",
+    "{#}/uL" = "{#}/uL",
+    "K[iU]/mL" = "k[iU]/mL",
+    "[pouce]" = "[pouce]",
+    "/kg{body_wt}" = "/kg{body_wt}",
+    "[Cal]" = "[Cal]",
+    "Meq/g{Cre}" = "meq/g{Cre}",
+    "%{risk}" = "%{risk}",
+    "[degF]" = "[degF]",
+    "ML/kg" = "mL/kg",
+    "U/h" = "U/h",
+    "G.m" = "g.m",
+    "MU/g{prot}" = "mU/g{prot}",
+    "M[IU]/L" = "m[IU]/L",
+    "{# of calculi}" = "{# of calculi}",
+    "%{dose}" = "%{dose}",
+    "{TIBC'U}" = "{TIBC'U}",
+    "{relative_saturation}" = "{relative_saturation}",
+    "Kg/min" = "kg/min",
+    "MU/L" = "mU/L",
+    "{Ehrlich'U}/dL" = "{Ehrlich'U}/dL",
+    "[cr_i]" = "[cr_i]",
+    "[beth'U]" = "[beth'U]",
+    "{yyyy}" = "{yyyy}",
+    "[hp_X]" = "[hp_X]",
+    "Mmol/(24.h)" = "mmol/(24.h)",
+    "{Spermatozoa}/mL" = "{Spermatozoa}/mL",
+    "Mbar.s/L" = "mbar.s/L",
+    "Ng/mg{Protein}" = "ng/mg{Protein}",
+    "/100{Spermatozoa}" = "/100{Spermatozoa}",
+    "{EV}" = "{EV}",
+    "MU/mL" = "mU/mL",
+    "Mg/(12.h)" = "mg/(12.h)",
+    "[MET].min/wk" = "[MET].min/wk",
+    "{AspirinReaction'U}" = "{AspirinReaction'U}",
+    "Kg/mol" = "kg/mol",
+    "{cfu}/mL" = "{cfu}/mL",
+    "Kg/m3" = "kg/m3",
+    Mm2 = "mm2",
+    "Umol/mol{Hb}" = "umol/mol{Hb}",
+    "ML/cm[H2O]" = "mL/cm[H2O]",
+    "{EIA_index}" = "{EIA_index}",
+    "U/d" = "U/d",
+    Fm = "fm",
+    "Cal_m" = "cal_m",
+    "KU/L" = "kU/L",
+    "S/{control}" = "s/{control}",
+    "Umol{BCE}/mol" = "umol{BCE}/mol",
+    "{GliadinIndexValue}" = "{GliadinIndexValue}",
+    "Ng/(kg.min)" = "ng/(kg.min)",
+    "{Index_val}" = "{Index_val}",
+    "[IU]/mL" = "[IU]/mL",
+    "Ug/kg/min" = "ug/kg/min",
+    "Deg/s" = "deg/s",
+    "U[IU]/L" = "u[IU]/L",
+    "Mmol/mmol{creat}" = "mmol/mmol{creat}",
+    "Umol/min/g{mucosa}" = "umol/min/g{mucosa}",
+    "{DeltaOpticalDensity}" = "{DeltaOpticalDensity}",
+    "{WeeksDays}" = "{WeeksDays}",
+    "[pH]" = "[pH]",
+    Dyn = "dyn",
+    Ng = "ng",
+    "%{RBCs}" = "%{RBCs}",
+    "Ng/kg/(8.h)" = "ng/kg/(8.h)",
+    "[IU]/h" = "[IU]/h",
+    "[mesh_i]" = "[mesh_i]",
+    "[lne]" = "[lne]",
+    "Mg/g{feces}" = "mg/g{feces}",
+    "[dr_av]" = "[dr_av]",
+    "{ActivityCoefficient}" = "{ActivityCoefficient}",
+    "Nmol/mmol{Cre}" = "nmol/mmol{Cre}",
+    "%{excretion}" = "%{excretion}",
+    "L/L" = "L/L",
+    "Num10*3/mL" = "10*3/mL",
+    PL = "pL"
+}
 /** What was the estimated risk */
 export interface RiskEvidenceSynthesisRiskEstimate extends BackboneElement {
     /** Description of risk estimate */
@@ -155,7 +1575,7 @@ export interface RiskEvidenceSynthesisRiskEstimate extends BackboneElement {
     denominatorCount?: integer;
     _description?: Element;
     /** What unit is the outcome described in? */
-    unitOfMeasure?: CodeableConcept;
+    unitOfMeasure?: `${RiskEvidenceSynthesisUnitOfMeasure}`;
     _numeratorCount?: Element;
     _denominatorCount?: Element;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/RiskEvidenceSynthesis.js b/vendor/r4/types/hl7-fhir-r4-core/RiskEvidenceSynthesis.js
index c8ad2e5..d64c2e9 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/RiskEvidenceSynthesis.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/RiskEvidenceSynthesis.js
@@ -1,2 +1,1425 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiskEvidenceSynthesisUnitOfMeasure = exports.RiskEvidenceSynthesisStatus = void 0;
+/** draft | active | retired | unknown */
+var RiskEvidenceSynthesisStatus;
+(function (RiskEvidenceSynthesisStatus) {
+    RiskEvidenceSynthesisStatus["Active"] = "active";
+    RiskEvidenceSynthesisStatus["Draft"] = "draft";
+    RiskEvidenceSynthesisStatus["Retired"] = "retired";
+    RiskEvidenceSynthesisStatus["Unknown"] = "unknown";
+})(RiskEvidenceSynthesisStatus = exports.RiskEvidenceSynthesisStatus || (exports.RiskEvidenceSynthesisStatus = {}));
+/** What unit is the outcome described in? */
+var RiskEvidenceSynthesisUnitOfMeasure;
+(function (RiskEvidenceSynthesisUnitOfMeasure) {
+    RiskEvidenceSynthesisUnitOfMeasure["Mo_j"] = "mo_j";
+    RiskEvidenceSynthesisUnitOfMeasure["CSt"] = "cSt";
+    RiskEvidenceSynthesisUnitOfMeasure["%{breakdown}"] = "%{breakdown}";
+    RiskEvidenceSynthesisUnitOfMeasure["{rel_saturation}"] = "{rel_saturation}";
+    RiskEvidenceSynthesisUnitOfMeasure["Fmol/g"] = "fmol/g";
+    RiskEvidenceSynthesisUnitOfMeasure["{Pouches}/wk"] = "{Pouches}/wk";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/mL"] = "umol/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Kg/s"] = "kg/s";
+    RiskEvidenceSynthesisUnitOfMeasure["Bq"] = "Bq";
+    RiskEvidenceSynthesisUnitOfMeasure["KPa"] = "kPa";
+    RiskEvidenceSynthesisUnitOfMeasure["Mosm/kg"] = "mosm/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/L"] = "mg/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/kg"] = "meq/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/(24.h)"] = "nmol/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["U/mol"] = "U/mol";
+    RiskEvidenceSynthesisUnitOfMeasure["T"] = "T";
+    RiskEvidenceSynthesisUnitOfMeasure["K[IU]/mL"] = "k[IU]/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["B[V]"] = "B[V]";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/g"] = "pmol/g";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*5"] = "10*5";
+    RiskEvidenceSynthesisUnitOfMeasure["Cm"] = "cm";
+    RiskEvidenceSynthesisUnitOfMeasure["{WhiteBloodCell}"] = "{WhiteBloodCell}";
+    RiskEvidenceSynthesisUnitOfMeasure["{MPS'U}"] = "{MPS'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/g{dry_wt}"] = "nmol/g{dry_wt}";
+    RiskEvidenceSynthesisUnitOfMeasure["Gf"] = "gf";
+    RiskEvidenceSynthesisUnitOfMeasure["{MPortionPhospholipids}"] = "{M-PortionPhospholipids}";
+    RiskEvidenceSynthesisUnitOfMeasure["{titer}"] = "{titer}";
+    RiskEvidenceSynthesisUnitOfMeasure["/g"] = "/g";
+    RiskEvidenceSynthesisUnitOfMeasure["{Breaths}/min"] = "{Breaths}/min";
+    RiskEvidenceSynthesisUnitOfMeasure["KU/mL"] = "kU/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["[rd_us]"] = "[rd_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["U{37Cel}/L"] = "U{37Cel}/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/H/mg{protein}"] = "pmol/H/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["[fth_us]"] = "[fth_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Fmol/mg{cyt_prot}"] = "fmol/mg{cyt_prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(kg.h)"] = "g/(kg.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["%{vol}"] = "%{vol}";
+    RiskEvidenceSynthesisUnitOfMeasure["/{entity}"] = "/{entity}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mol/mol"] = "mol/mol";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/h/g"] = "umol/h/g";
+    RiskEvidenceSynthesisUnitOfMeasure["Dm"] = "dm";
+    RiskEvidenceSynthesisUnitOfMeasure["[ston_av]"] = "[ston_av]";
+    RiskEvidenceSynthesisUnitOfMeasure["G/g{Cre}"] = "g/g{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Inhibition}"] = "%{Inhibition}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mol"] = "mol";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/h/mg{prot}"] = "pmol/h/mg{prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["K"] = "K";
+    RiskEvidenceSynthesisUnitOfMeasure["{ComplementActivityEnzyme'U}"] = "{ComplementActivityEnzyme'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{WeightToWeight}"] = "%{WeightToWeight}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{bacteria}"] = "%{bacteria}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/(8.h.kg)"] = "mg/(8.h.kg)";
+    RiskEvidenceSynthesisUnitOfMeasure["Cm[H2O]/(s.m)"] = "cm[H2O]/(s.m)";
+    RiskEvidenceSynthesisUnitOfMeasure["[smi_us]"] = "[smi_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/min"] = "nmol/min";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Bound}"] = "%{Bound}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/kg"] = "g/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["Att"] = "att";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/L{RBCs}"] = "mg/L{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/(72.h)"] = "mL/(72.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["G.m/{hb}"] = "g.m/{hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/m2"] = "ug/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/umol"] = "pmol/umol";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/(kg.d)"] = "meq/(kg.d)";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*3{Copies}/mL"] = "10*3{Copies}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/kg/(24.h)"] = "mg/kg/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Mm[Hg]"] = "mm[Hg]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/dL{rbc}"] = "ug/dL{rbc}";
+    RiskEvidenceSynthesisUnitOfMeasure["U/10*6"] = "U/10*6";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/d"] = "ng/d";
+    RiskEvidenceSynthesisUnitOfMeasure["[USP'U]"] = "[USP'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/(2.h)"] = "mmol/(2.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10.uN.s/(cm.m2)"] = "10.uN.s/(cm.m2)";
+    RiskEvidenceSynthesisUnitOfMeasure["[in_us]"] = "[in_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Fmol"] = "fmol";
+    RiskEvidenceSynthesisUnitOfMeasure["Fmol/mg{protein}"] = "fmol/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/L/mmol{creat}"] = "nmol/L/mmol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["[Btu]"] = "[Btu]";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/{RBC}"] = "pmol/{RBC}";
+    RiskEvidenceSynthesisUnitOfMeasure["/10*3.{RBCs}"] = "/10*3.{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/mmol{creat}"] = "g/mmol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["{AntibodyResponse'U}"] = "{AntibodyResponse'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/kg"] = "[IU]/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["U/kg{hemoglobin}"] = "U/kg{hemoglobin}";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/mg"] = "mU/mg";
+    RiskEvidenceSynthesisUnitOfMeasure["Cm[H2O]"] = "cm[H2O]";
+    RiskEvidenceSynthesisUnitOfMeasure["AU"] = "AU";
+    RiskEvidenceSynthesisUnitOfMeasure["Pg/{RBC}"] = "pg/{RBC}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{reactive}"] = "%{reactive}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/g{globulin}"] = "g/g{globulin}";
+    RiskEvidenceSynthesisUnitOfMeasure["{cells}"] = "{cells}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Live}"] = "%{Live}";
+    RiskEvidenceSynthesisUnitOfMeasure["[pwt_tr]"] = "[pwt_tr]";
+    RiskEvidenceSynthesisUnitOfMeasure["[ligne]"] = "[ligne]";
+    RiskEvidenceSynthesisUnitOfMeasure["{IFA_index}"] = "{IFA_index}";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/mL/min"] = "mU/mL/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*"] = "10*";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/min/mg{prot}"] = "pmol/min/mg{prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["[G]"] = "[G]";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/(24.h)"] = "mL/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[ka'U]"] = "[ka'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["G/L"] = "g/L";
+    RiskEvidenceSynthesisUnitOfMeasure["/100"] = "/100";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/mL{rbc}"] = "ng/mL{rbc}";
+    RiskEvidenceSynthesisUnitOfMeasure["st"] = "st";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/mol"] = "umol/mol";
+    RiskEvidenceSynthesisUnitOfMeasure["Kat/L"] = "kat/L";
+    RiskEvidenceSynthesisUnitOfMeasure["U/g{hemoglobin}"] = "U/g{hemoglobin}";
+    RiskEvidenceSynthesisUnitOfMeasure["KU/L{class}"] = "kU/L{class}";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/mg{prot}"] = "pmol/mg{prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/h/mg{protein}"] = "nmol/h/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*3{copies}/mL"] = "10*3{copies}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/h"] = "mmol/h";
+    RiskEvidenceSynthesisUnitOfMeasure["[ppth]"] = "[ppth]";
+    RiskEvidenceSynthesisUnitOfMeasure["{genomes}/mL"] = "{genomes}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol"] = "mmol";
+    RiskEvidenceSynthesisUnitOfMeasure["Gon"] = "gon";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/dL/h"] = "ng/dL/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/mmol"] = "mg/mmol";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/mmol{Cre}"] = "mg/mmol{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["/100{neutrophils}"] = "/100{neutrophils}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/(18.h)"] = "mmol/(18.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/min"] = "mmol/min";
+    RiskEvidenceSynthesisUnitOfMeasure["{spermatozoa}/mL"] = "{spermatozoa}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/mg{Cre}"] = "mg/mg{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/kg/h"] = "ng/kg/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/(kg.h)"] = "ug/(kg.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{ToxoplasmaIndexValue}"] = "{ToxoplasmaIndexValue}";
+    RiskEvidenceSynthesisUnitOfMeasure["/[IU]"] = "/[IU]";
+    RiskEvidenceSynthesisUnitOfMeasure["/d"] = "/d";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/(10.h)"] = "mg/(10.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[cin_i]"] = "[cin_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["[oz_av]"] = "[oz_av]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/10*6"] = "ng/10*6";
+    RiskEvidenceSynthesisUnitOfMeasure["%{HemoglobinA1C}"] = "%{HemoglobinA1C}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Ehrlich'U}/mL"] = "{Ehrlich'U}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["{Applicator}"] = "{Applicator}";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol"] = "pmol";
+    RiskEvidenceSynthesisUnitOfMeasure["M[IU]/mL"] = "m[IU]/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/g{creat}"] = "mg/g{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["U/mL"] = "U/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["[scwt_av]"] = "[scwt_av]";
+    RiskEvidenceSynthesisUnitOfMeasure["[cicero]"] = "[cicero]";
+    RiskEvidenceSynthesisUnitOfMeasure["s"] = "s";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/(5.h)"] = "mmol/(5.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/h/mg{protein}"] = "pmol/h/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["{ElisaU}/mL"] = "{ElisaU}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*12/L"] = "10*12/L";
+    RiskEvidenceSynthesisUnitOfMeasure["G%"] = "g%";
+    RiskEvidenceSynthesisUnitOfMeasure["Mol/mL"] = "mol/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/dL"] = "meq/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["Lx"] = "lx";
+    RiskEvidenceSynthesisUnitOfMeasure["{Bottle}"] = "{Bottle}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol{ATP}"] = "nmol{ATP}";
+    RiskEvidenceSynthesisUnitOfMeasure["Lm"] = "lm";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/mL/h"] = "ng/mL/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/g{Tissue}"] = "ug/g{Tissue}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/dL{GF}"] = "umol/dL{GF}";
+    RiskEvidenceSynthesisUnitOfMeasure["/kg{body'wt}"] = "/kg{body'wt}";
+    RiskEvidenceSynthesisUnitOfMeasure["{rbc}"] = "{rbc}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug{T4}/dL"] = "ug{T4}/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/mmol"] = "umol/mmol";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*3/uL"] = "10*3/uL";
+    RiskEvidenceSynthesisUnitOfMeasure["{Log_copies}/mL"] = "{Log_copies}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Fmol/mg"] = "fmol/mg";
+    RiskEvidenceSynthesisUnitOfMeasure["Lm/m2"] = "lm/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["%{blockade}"] = "%{blockade}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/mL{class}"] = "ug/mL{class}";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/min"] = "mU/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Gy"] = "Gy";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*3"] = "10*3";
+    RiskEvidenceSynthesisUnitOfMeasure["/[HPF]"] = "/[HPF]";
+    RiskEvidenceSynthesisUnitOfMeasure["{M.o.M}"] = "{M.o.M}";
+    RiskEvidenceSynthesisUnitOfMeasure["Pg/mL"] = "pg/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["{JDF'U}"] = "{JDF'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["A_t"] = "a_t";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/g{Hgb}"] = "ug/g{Hgb}";
+    RiskEvidenceSynthesisUnitOfMeasure["[sin_i]"] = "[sin_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/h/mL"] = "pmol/h/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["U{25Cel}/L"] = "U{25Cel}/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10^"] = "10^";
+    RiskEvidenceSynthesisUnitOfMeasure["{WBCs}"] = "{WBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["{4 times}/d"] = "{4 times}/d";
+    RiskEvidenceSynthesisUnitOfMeasure["Ci"] = "Ci";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/g{tissue}"] = "mg/g{tissue}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/ng"] = "ug/ng";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/L{37Cel}"] = "[IU]/L{37Cel}";
+    RiskEvidenceSynthesisUnitOfMeasure["Pa"] = "Pa";
+    RiskEvidenceSynthesisUnitOfMeasure["{ERY}/uL"] = "{ERY}/uL";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/umol{creat}"] = "pmol/umol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["{binding_index}"] = "{binding_index}";
+    RiskEvidenceSynthesisUnitOfMeasure["MeV"] = "MeV";
+    RiskEvidenceSynthesisUnitOfMeasure["B[kW]"] = "B[kW]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/kg/d"] = "mg/kg/d";
+    RiskEvidenceSynthesisUnitOfMeasure["/ug"] = "/ug";
+    RiskEvidenceSynthesisUnitOfMeasure["GBq"] = "GBq";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/(kg.d)"] = "ug/(kg.d)";
+    RiskEvidenceSynthesisUnitOfMeasure["[tsp_us]"] = "[tsp_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/g{dry_tissue}"] = "mg/g{dry_tissue}";
+    RiskEvidenceSynthesisUnitOfMeasure["/10*3"] = "/10*3";
+    RiskEvidenceSynthesisUnitOfMeasure["UOhm"] = "uOhm";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/(8.h)"] = "mL/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["/100{spermatozoa}"] = "/100{spermatozoa}";
+    RiskEvidenceSynthesisUnitOfMeasure["Fmol/mL"] = "fmol/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["{# of fetuses}"] = "{# of fetuses}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/mL{eqv}"] = "ug/mL{eqv}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Packs}/d"] = "{Packs}/d";
+    RiskEvidenceSynthesisUnitOfMeasure["[S]"] = "[S]";
+    RiskEvidenceSynthesisUnitOfMeasure["G/min"] = "g/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mol"] = "nmol/mol";
+    RiskEvidenceSynthesisUnitOfMeasure["MU"] = "mU";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug"] = "ug";
+    RiskEvidenceSynthesisUnitOfMeasure["Ml"] = "ml";
+    RiskEvidenceSynthesisUnitOfMeasure["%[slope]"] = "%[slope]";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/mg{creat}"] = "mU/mg{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["G.m/{beat}"] = "g.m/{beat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Num1/d"] = "1/d";
+    RiskEvidenceSynthesisUnitOfMeasure["B[mV]"] = "B[mV]";
+    RiskEvidenceSynthesisUnitOfMeasure["MBq"] = "MBq";
+    RiskEvidenceSynthesisUnitOfMeasure["UU"] = "uU";
+    RiskEvidenceSynthesisUnitOfMeasure["[PRU]"] = "[PRU]";
+    RiskEvidenceSynthesisUnitOfMeasure["{Cells}/mL"] = "{Cells}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["L/(min.m2)"] = "L/(min.m2)";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/L"] = "ug/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Kg/m2"] = "kg/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["[smoot]"] = "[smoot]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/dL"] = "ug/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["[p'diop]"] = "[p'diop]";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mg{prot}"] = "nmol/mg{prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["[ppm]"] = "[ppm]";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Total}"] = "%{Total}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(24.h)"] = "g/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*Num3{Polarization'U}"] = "10*-3{Polarization'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["Pm"] = "pm";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/h/mg{protein}"] = "umol/h/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["G{total_prot}"] = "g{total_prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["/10*9"] = "/10*9";
+    RiskEvidenceSynthesisUnitOfMeasure["/g{wet_tis}"] = "/g{wet_tis}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{inhibition}"] = "%{inhibition}";
+    RiskEvidenceSynthesisUnitOfMeasure["/100{cells}"] = "/100{cells}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/min/mg{prot}"] = "nmol/min/mg{prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["B[SPL]"] = "B[SPL]";
+    RiskEvidenceSynthesisUnitOfMeasure["{Events}"] = "{Events}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/kg"] = "ng/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["[gal_br]"] = "[gal_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["/a"] = "/a";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/m/mg{prot}"] = "nmol/m/mg{prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["{#}/[LPF]"] = "{#}/[LPF]";
+    RiskEvidenceSynthesisUnitOfMeasure["G/{total_weight}"] = "g/{total_weight}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mg{protein}"] = "nmol/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["[fdr_us]"] = "[fdr_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/mg"] = "ug/mg";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/{specimen}"] = "ug/{specimen}";
+    RiskEvidenceSynthesisUnitOfMeasure["U/(24.h)"] = "U/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/mmol"] = "mmol/mmol";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/kg/h"] = "mmol/kg/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug{FEU}/mL"] = "ug{FEU}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["ML"] = "mL";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/[sin_i]"] = "mL/[sin_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6/(24.h)"] = "10*6/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["U/min"] = "U/min";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/d"] = "mL/d";
+    RiskEvidenceSynthesisUnitOfMeasure["[APL'U]/mL"] = "[APL'U]/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["''"] = "''";
+    RiskEvidenceSynthesisUnitOfMeasure["%{0to3Hours}"] = "%{0to3Hours}";
+    RiskEvidenceSynthesisUnitOfMeasure["[lbf_av]"] = "[lbf_av]";
+    RiskEvidenceSynthesisUnitOfMeasure["H/wk"] = "h/wk";
+    RiskEvidenceSynthesisUnitOfMeasure["/10*12{RBCs}"] = "/10*12{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["/h"] = "/h";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Hemolysis}"] = "%{Hemolysis}";
+    RiskEvidenceSynthesisUnitOfMeasure["/kg"] = "/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["U/g{Hb}"] = "U/g{Hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["[MPL'U]"] = "[MPL'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/mol{creat}"] = "mmol/mol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/g{wet_tissue}"] = "mg/g{wet_tissue}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/L{RBCs}"] = "umol/L{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["Rad"] = "rad";
+    RiskEvidenceSynthesisUnitOfMeasure["Ueq"] = "ueq";
+    RiskEvidenceSynthesisUnitOfMeasure["Ohm.m"] = "Ohm.m";
+    RiskEvidenceSynthesisUnitOfMeasure["{OpticalDensityIndex}"] = "{OpticalDensityIndex}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/(kg.h)"] = "ng/(kg.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/kg/min"] = "mmol/kg/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10.L/(min.m2)"] = "10.L/(min.m2)";
+    RiskEvidenceSynthesisUnitOfMeasure["%{BasalActivity}"] = "%{BasalActivity}";
+    RiskEvidenceSynthesisUnitOfMeasure["[APL'U]"] = "[APL'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["[Btu_39]"] = "[Btu_39]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/mg"] = "ng/mg";
+    RiskEvidenceSynthesisUnitOfMeasure["B[W]"] = "B[W]";
+    RiskEvidenceSynthesisUnitOfMeasure["DL"] = "dL";
+    RiskEvidenceSynthesisUnitOfMeasure["{CGG_repeats}"] = "{CGG_repeats}";
+    RiskEvidenceSynthesisUnitOfMeasure["U/kg{Hb}"] = "U/kg{Hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/(kg.h)"] = "mg/(kg.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*9/mL"] = "10*9/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Nm"] = "nm";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/L"] = "ng/L";
+    RiskEvidenceSynthesisUnitOfMeasure["{mutation}"] = "{mutation}";
+    RiskEvidenceSynthesisUnitOfMeasure["EV"] = "eV";
+    RiskEvidenceSynthesisUnitOfMeasure["[drp]/[HPF]"] = "[drp]/[HPF]";
+    RiskEvidenceSynthesisUnitOfMeasure["%{response}"] = "%{response}";
+    RiskEvidenceSynthesisUnitOfMeasure["/min"] = "/min";
+    RiskEvidenceSynthesisUnitOfMeasure["/[LPF]"] = "/[LPF]";
+    RiskEvidenceSynthesisUnitOfMeasure["[pca]"] = "[pca]";
+    RiskEvidenceSynthesisUnitOfMeasure["[pk_us]"] = "[pk_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["{ComplementCH50'U}"] = "{ComplementCH50'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6.[IU]"] = "10*6.[IU]";
+    RiskEvidenceSynthesisUnitOfMeasure["M/s2"] = "m/s2";
+    RiskEvidenceSynthesisUnitOfMeasure["{cells}/uL"] = "{cells}/uL";
+    RiskEvidenceSynthesisUnitOfMeasure["%{WBCs}"] = "%{WBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/g"] = "meq/g";
+    RiskEvidenceSynthesisUnitOfMeasure["{3 times}/d"] = "{3 times}/d";
+    RiskEvidenceSynthesisUnitOfMeasure["{GPortionPhospholipids}"] = "{G-PortionPhospholipids}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol"] = "umol";
+    RiskEvidenceSynthesisUnitOfMeasure["Fmol/L"] = "fmol/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/mol{creat}"] = "umol/mol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Volume}/{Vvolume}"] = "{Volume}/{Vvolume}";
+    RiskEvidenceSynthesisUnitOfMeasure["Wb"] = "Wb";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/min/mg{Hb}"] = "nmol/min/mg{Hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["{ARU}"] = "{ARU}";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/{beat}"] = "mL/{beat}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Dose}"] = "{Dose}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ukat"] = "ukat";
+    RiskEvidenceSynthesisUnitOfMeasure["Mm3"] = "mm3";
+    RiskEvidenceSynthesisUnitOfMeasure["{Dalton}"] = "{Dalton}";
+    RiskEvidenceSynthesisUnitOfMeasure["L"] = "L";
+    RiskEvidenceSynthesisUnitOfMeasure["U/g{Cre}"] = "U/g{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["{#}"] = "{#}";
+    RiskEvidenceSynthesisUnitOfMeasure["mv"] = "mV";
+    RiskEvidenceSynthesisUnitOfMeasure["%{binding}"] = "%{binding}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mg{prot}/h"] = "nmol/mg{prot}/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg"] = "mg";
+    RiskEvidenceSynthesisUnitOfMeasure["%{pooled_plasma}"] = "%{pooled_plasma}";
+    RiskEvidenceSynthesisUnitOfMeasure["{OpticalDensity}"] = "{OpticalDensity}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/{TotalVolume}"] = "ug/{TotalVolume}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{NormalControl}"] = "%{NormalControl}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Log}"] = "{Log}";
+    RiskEvidenceSynthesisUnitOfMeasure["[m_p]"] = "[m_p]";
+    RiskEvidenceSynthesisUnitOfMeasure["%/100{WBC}"] = "%/100{WBC}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/{Specimen}"] = "mg/{Specimen}";
+    RiskEvidenceSynthesisUnitOfMeasure["Kcal/kg/(24.h)"] = "kcal/kg/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/mg{Cre}"] = "ug/mg{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["[LPF]"] = "[LPF]";
+    RiskEvidenceSynthesisUnitOfMeasure["M2"] = "m2";
+    RiskEvidenceSynthesisUnitOfMeasure["Num1"] = "1";
+    RiskEvidenceSynthesisUnitOfMeasure["Bit"] = "bit";
+    RiskEvidenceSynthesisUnitOfMeasure["{CPM}"] = "{CPM}";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6/L"] = "10*6/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/g{DryWeight}"] = "ug/g{DryWeight}";
+    RiskEvidenceSynthesisUnitOfMeasure["[hp_M]"] = "[hp_M]";
+    RiskEvidenceSynthesisUnitOfMeasure["/10*6"] = "/10*6";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng{FEU}/mL"] = "ng{FEU}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["{Package}"] = "{Package}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ueq/mL"] = "ueq/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/mmol{creat}"] = "mg/mmol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/g{creat}"] = "umol/g{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mol/m3"] = "mol/m3";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/g{Hgb}"] = "mU/g{Hgb}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mmol{creat}"] = "nmol/mmol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{loss_AChR}"] = "%{loss_AChR}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/min/L"] = "umol/min/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Mol/L"] = "mol/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Ky"] = "Ky";
+    RiskEvidenceSynthesisUnitOfMeasure["{Molecule}/{Platelet}"] = "{Molecule}/{Platelet}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/dL"] = "mmol/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*3/L"] = "10*3/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Pg/mg{creat}"] = "pg/mg{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/L"] = "meq/L";
+    RiskEvidenceSynthesisUnitOfMeasure["%{hemolysis}"] = "%{hemolysis}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(8.h){shift}"] = "g/(8.h){shift}";
+    RiskEvidenceSynthesisUnitOfMeasure["[lk_br]"] = "[lk_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["L/s"] = "L/s";
+    RiskEvidenceSynthesisUnitOfMeasure["L/min"] = "L/min";
+    RiskEvidenceSynthesisUnitOfMeasure["U/g{creat}"] = "U/g{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mx"] = "Mx";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Negative Control}"] = "%{Negative Control}";
+    RiskEvidenceSynthesisUnitOfMeasure["NU/{RBC}"] = "nU/{RBC}";
+    RiskEvidenceSynthesisUnitOfMeasure["Erg"] = "erg";
+    RiskEvidenceSynthesisUnitOfMeasure["L/h"] = "L/h";
+    RiskEvidenceSynthesisUnitOfMeasure["%{TotalProtein}"] = "%{TotalProtein}";
+    RiskEvidenceSynthesisUnitOfMeasure["K[IU]/L"] = "k[IU]/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/{Tot'Volume}"] = "mg/{Tot'Volume}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{abnormal}"] = "%{abnormal}";
+    RiskEvidenceSynthesisUnitOfMeasure["[in_i'H2O]"] = "[in_i'H2O]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ms"] = "Ms";
+    RiskEvidenceSynthesisUnitOfMeasure["{Tscore}"] = "{Tscore}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/mol{Cre}"] = "mmol/mol{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["KU/h"] = "kU/h";
+    RiskEvidenceSynthesisUnitOfMeasure["A/m"] = "A/m";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/g{Cre}"] = "ug/g{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["[dr_ap]"] = "[dr_ap]";
+    RiskEvidenceSynthesisUnitOfMeasure["{HaTiter}"] = "{HaTiter}";
+    RiskEvidenceSynthesisUnitOfMeasure["Kat"] = "kat";
+    RiskEvidenceSynthesisUnitOfMeasure["{copies}/mL"] = "{copies}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/min"] = "mL/min";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/(12.h)"] = "mL/(12.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[hnsf'U]"] = "[hnsf'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6/{Specimen}"] = "10*6/{Specimen}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/mg{protein}"] = "ng/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["/[iU]"] = "/[iU]";
+    RiskEvidenceSynthesisUnitOfMeasure["Hz"] = "Hz";
+    RiskEvidenceSynthesisUnitOfMeasure["{FIU}"] = "{FIU}";
+    RiskEvidenceSynthesisUnitOfMeasure["[yd_br]"] = "[yd_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["{FluorescenceIntensity'U}"] = "{FluorescenceIntensity'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Rubella_virus}"] = "{Rubella_virus}";
+    RiskEvidenceSynthesisUnitOfMeasure["{P2Y12 Reaction Units}"] = "{P2Y12 Reaction Units}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Hemoglobin}"] = "%{Hemoglobin}";
+    RiskEvidenceSynthesisUnitOfMeasure["[drp]/mL"] = "[drp]/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["[cyd_i]"] = "[cyd_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["[fur_us]"] = "[fur_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["FL"] = "fL";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/(4.h)"] = "mL/(4.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{# of donor informative markers}"] = "{# of donor informative markers}";
+    RiskEvidenceSynthesisUnitOfMeasure["KV"] = "kV";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/m3"] = "mg/m3";
+    RiskEvidenceSynthesisUnitOfMeasure["[pt_us]"] = "[pt_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ueq/L"] = "ueq/L";
+    RiskEvidenceSynthesisUnitOfMeasure["%{ofAvailable}"] = "%{ofAvailable}";
+    RiskEvidenceSynthesisUnitOfMeasure["{phenotype}"] = "{phenotype}";
+    RiskEvidenceSynthesisUnitOfMeasure["[pc_br]"] = "[pc_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["G/mL"] = "g/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["[D'ag'U]"] = "[D'ag'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["G"] = "G";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/kg/(8.h)"] = "mg/kg/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[HPF]"] = "[HPF]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ps"] = "ps";
+    RiskEvidenceSynthesisUnitOfMeasure["L/s/s2"] = "L/s/s2";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6.eq/mL"] = "10*6.eq/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["KBq"] = "kBq";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/d/{1.73_m2}"] = "mg/d/{1.73_m2}";
+    RiskEvidenceSynthesisUnitOfMeasure["[AU]"] = "[AU]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ao"] = "Ao";
+    RiskEvidenceSynthesisUnitOfMeasure["[drp]/h"] = "[drp]/h";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/(8.h)/kg"] = "mL/(8.h)/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/mg{creat}"] = "mg/mg{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/L/(24.h)"] = "ug/L/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/mm"] = "mL/mm";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/L{RBCs}"] = "nmol/L{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["[car_Au]"] = "[car_Au]";
+    RiskEvidenceSynthesisUnitOfMeasure["Dg"] = "dg";
+    RiskEvidenceSynthesisUnitOfMeasure["Sr"] = "sr";
+    RiskEvidenceSynthesisUnitOfMeasure["%{normal}"] = "%{normal}";
+    RiskEvidenceSynthesisUnitOfMeasure["/{oif}"] = "/{oif}";
+    RiskEvidenceSynthesisUnitOfMeasure["{ElisaValue}"] = "{ElisaValue}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol{BCE}/mmol{creat}"] = "nmol{BCE}/mmol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/d"] = "mg/d";
+    RiskEvidenceSynthesisUnitOfMeasure["[Btu_th]"] = "[Btu_th]";
+    RiskEvidenceSynthesisUnitOfMeasure["[iU]/mL"] = "[iU]/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["{IndexValue}"] = "{IndexValue}";
+    RiskEvidenceSynthesisUnitOfMeasure["[GPL'U]/mL"] = "[GPL'U]/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["{Ct}"] = "{Ct}";
+    RiskEvidenceSynthesisUnitOfMeasure["{IFA_titer}"] = "{IFA_titer}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/{total_output}"] = "mg/{total_output}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{lysis}"] = "%{lysis}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/mg"] = "mg/mg";
+    RiskEvidenceSynthesisUnitOfMeasure["{JuvenileDiabetesFound'U}"] = "{JuvenileDiabetesFound'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Each}"] = "{Each}";
+    RiskEvidenceSynthesisUnitOfMeasure["[fth_br]"] = "[fth_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/mmol{RBCs}"] = "mU/mmol{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["{log_IU}/mL"] = "{log_IU}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/g{Cre}"] = "nmol/g{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Copies}/mL"] = "{Copies}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Cal_[15]"] = "cal_[15]";
+    RiskEvidenceSynthesisUnitOfMeasure["DB"] = "dB";
+    RiskEvidenceSynthesisUnitOfMeasure["[lb_tr]"] = "[lb_tr]";
+    RiskEvidenceSynthesisUnitOfMeasure["L/d"] = "L/d";
+    RiskEvidenceSynthesisUnitOfMeasure["[Btu_m]"] = "[Btu_m]";
+    RiskEvidenceSynthesisUnitOfMeasure["J"] = "J";
+    RiskEvidenceSynthesisUnitOfMeasure["MPa.s"] = "mPa.s";
+    RiskEvidenceSynthesisUnitOfMeasure["[iU]"] = "[iU]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/kg{H2O}"] = "mmol/kg{H2O}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mbar/L/s"] = "mbar/L/s";
+    RiskEvidenceSynthesisUnitOfMeasure["{RubellaVirus}"] = "{RubellaVirus}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/m/mg{protein}"] = "nmol/m/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["Pg/{cell}"] = "pg/{cell}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/wk"] = "mg/wk";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/g{hemoglobin}"] = "mmol/g{hemoglobin}";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/(2.h)"] = "[IU]/(2.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{EIATiter}"] = "{EIATiter}";
+    RiskEvidenceSynthesisUnitOfMeasure["{ISR}"] = "{ISR}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/mL{RBCs}"] = "ng/mL{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(48.h)"] = "g/(48.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["G/mg"] = "g/mg";
+    RiskEvidenceSynthesisUnitOfMeasure["FL/nL"] = "fL/nL";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/g"] = "nmol/g";
+    RiskEvidenceSynthesisUnitOfMeasure["[mu_0]"] = "[mu_0]";
+    RiskEvidenceSynthesisUnitOfMeasure["/(12.h)"] = "/(12.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[pi].rad/min"] = "[pi].rad/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/kg"] = "ug/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/min"] = "pmol/min";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/min"] = "[IU]/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Ks"] = "ks";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/m"] = "mmol/m";
+    RiskEvidenceSynthesisUnitOfMeasure["Ns"] = "ns";
+    RiskEvidenceSynthesisUnitOfMeasure["Kg{wet'tis}"] = "kg{wet'tis}";
+    RiskEvidenceSynthesisUnitOfMeasure["Kg/h"] = "kg/h";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Blockade}"] = "%{Blockade}";
+    RiskEvidenceSynthesisUnitOfMeasure["{minidrop}/s"] = "{minidrop}/s";
+    RiskEvidenceSynthesisUnitOfMeasure["G/kg/d"] = "g/kg/d";
+    RiskEvidenceSynthesisUnitOfMeasure["{KRONU'U}/mL"] = "{KRONU'U}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/{TotalVolume}"] = "mmol/{TotalVolume}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mo"] = "mo";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/(6.h)"] = "mmol/(6.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{CAG_repeats}"] = "{CAG_repeats}";
+    RiskEvidenceSynthesisUnitOfMeasure["J/L"] = "J/L";
+    RiskEvidenceSynthesisUnitOfMeasure["{IgAAntiphosphatidyleserine'U}"] = "{IgAAntiphosphatidyleserine'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["[BAU]"] = "[BAU]";
+    RiskEvidenceSynthesisUnitOfMeasure["M"] = "m";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/(12.h)"] = "meq/(12.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Gal"] = "Gal";
+    RiskEvidenceSynthesisUnitOfMeasure["[fdr_br]"] = "[fdr_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["{CPM}/10*3{cell}"] = "{CPM}/10*3{cell}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mg{creat}"] = "nmol/mg{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/h"] = "ug/h";
+    RiskEvidenceSynthesisUnitOfMeasure["{GAA_repeats}"] = "{GAA_repeats}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/g{tissue}"] = "ug/g{tissue}";
+    RiskEvidenceSynthesisUnitOfMeasure["[lk_us]"] = "[lk_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10.uN.s/(cm5.m2)"] = "10.uN.s/(cm5.m2)";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/{Specimen}"] = "ug/{Specimen}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/kg/d"] = "mmol/kg/d";
+    RiskEvidenceSynthesisUnitOfMeasure["{Bead}"] = "{Bead}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/{total_output}"] = "g/{total_output}";
+    RiskEvidenceSynthesisUnitOfMeasure["KU/g"] = "kU/g";
+    RiskEvidenceSynthesisUnitOfMeasure["PT"] = "pT";
+    RiskEvidenceSynthesisUnitOfMeasure["/{tot}"] = "/{tot}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/min/10*6{cells}"] = "nmol/min/10*6{cells}";
+    RiskEvidenceSynthesisUnitOfMeasure["Kg/(s.m2)"] = "kg/(s.m2)";
+    RiskEvidenceSynthesisUnitOfMeasure["{cfu}"] = "{cfu}";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/(kg.min)"] = "mL/(kg.min)";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/{h'b}"] = "mL/{h'b}";
+    RiskEvidenceSynthesisUnitOfMeasure["[pi]"] = "[pi]";
+    RiskEvidenceSynthesisUnitOfMeasure["Oe"] = "Oe";
+    RiskEvidenceSynthesisUnitOfMeasure["UL/(2.h)"] = "uL/(2.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["UU/g"] = "uU/g";
+    RiskEvidenceSynthesisUnitOfMeasure["St"] = "St";
+    RiskEvidenceSynthesisUnitOfMeasure["/g{wet'tis}"] = "/g{wet'tis}";
+    RiskEvidenceSynthesisUnitOfMeasure["{risk}"] = "{risk}";
+    RiskEvidenceSynthesisUnitOfMeasure["{INR}"] = "{INR}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/mL"] = "mg/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/(6.h)"] = "mL/(6.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{count}"] = "{count}";
+    RiskEvidenceSynthesisUnitOfMeasure["[acr_us]"] = "[acr_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/mg{prot}"] = "ng/mg{prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6/uL"] = "10*6/uL";
+    RiskEvidenceSynthesisUnitOfMeasure["{#}/d"] = "{#}/d";
+    RiskEvidenceSynthesisUnitOfMeasure["{LymeIndexValue}"] = "{LymeIndexValue}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mho"] = "mho";
+    RiskEvidenceSynthesisUnitOfMeasure["{index}"] = "{index}";
+    RiskEvidenceSynthesisUnitOfMeasure["U/g{protein}"] = "U/g{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["{#}/wk"] = "{#}/wk";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/m"] = "umol/m";
+    RiskEvidenceSynthesisUnitOfMeasure["Sv"] = "Sv";
+    RiskEvidenceSynthesisUnitOfMeasure["[lb_av]"] = "[lb_av]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mol/mol{creat}"] = "mol/mol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["[lcwt_av]"] = "[lcwt_av]";
+    RiskEvidenceSynthesisUnitOfMeasure["/g{tot_prot}"] = "/g{tot_prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/kg/d"] = "ug/kg/d";
+    RiskEvidenceSynthesisUnitOfMeasure["{KRONU'U}/L"] = "{KRONU'U}/L";
+    RiskEvidenceSynthesisUnitOfMeasure["[iU]/dL"] = "[iU]/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["S"] = "S";
+    RiskEvidenceSynthesisUnitOfMeasure["{IgGAntiphosphatidyleserine'U}"] = "{IgGAntiphosphatidyleserine'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/g{hair}"] = "ug/g{hair}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{baseline}"] = "%{baseline}";
+    RiskEvidenceSynthesisUnitOfMeasure["{EIA'U}/U"] = "{EIA'U}/U";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/g{Cre}"] = "umol/g{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["L.s2/s"] = "L.s2/s";
+    RiskEvidenceSynthesisUnitOfMeasure["[kn_i]"] = "[kn_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["G{creat}"] = "g{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["[Btu_IT]"] = "[Btu_IT]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg{creat}"] = "mg{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/min"] = "ng/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/mmol{creat}"] = "ug/mmol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["[min_br]"] = "[min_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["%{SpermMotility}"] = "%{SpermMotility}";
+    RiskEvidenceSynthesisUnitOfMeasure["[in_i]"] = "[in_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["{Log_IU}/mL"] = "{Log_IU}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["{Ehrlich'U}/100.g"] = "{Ehrlich'U}/100.g";
+    RiskEvidenceSynthesisUnitOfMeasure["[drp]"] = "[drp]";
+    RiskEvidenceSynthesisUnitOfMeasure["{Vial}"] = "{Vial}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/dL"] = "mg/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["Cm[H2O]/L/s"] = "cm[H2O]/L/s";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/umol{creat}"] = "nmol/umol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["{INR'unit}"] = "{INR'unit}";
+    RiskEvidenceSynthesisUnitOfMeasure["[car_m]"] = "[car_m]";
+    RiskEvidenceSynthesisUnitOfMeasure["/g{Hb}"] = "/g{Hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["{#}/min"] = "{#}/min";
+    RiskEvidenceSynthesisUnitOfMeasure["U/umol"] = "U/umol";
+    RiskEvidenceSynthesisUnitOfMeasure["{IgGIndex}"] = "{IgGIndex}";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/(5.h)"] = "mL/(5.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{Pill}"] = "{Pill}";
+    RiskEvidenceSynthesisUnitOfMeasure["[CFU]"] = "[CFU]";
+    RiskEvidenceSynthesisUnitOfMeasure["{Cans}/wk"] = "{Cans}/wk";
+    RiskEvidenceSynthesisUnitOfMeasure["[nmi_br]"] = "[nmi_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["Lm.m2"] = "lm.m2";
+    RiskEvidenceSynthesisUnitOfMeasure["[nmi_i]"] = "[nmi_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["H"] = "H";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(8.h)"] = "g/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["/m3"] = "/m3";
+    RiskEvidenceSynthesisUnitOfMeasure["M2/s"] = "m2/s";
+    RiskEvidenceSynthesisUnitOfMeasure["Deg"] = "deg";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/(6.h)"] = "mg/(6.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[gal_us]"] = "[gal_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Cm[Hg]"] = "cm[Hg]";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/(2.h)"] = "mL/(2.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["/{Specimen}"] = "/{Specimen}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mg{protein}/h"] = "nmol/mg{protein}/h";
+    RiskEvidenceSynthesisUnitOfMeasure["{CfTiter}"] = "{CfTiter}";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/{total_volume}"] = "meq/{total_volume}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mosm"] = "mosm";
+    RiskEvidenceSynthesisUnitOfMeasure["[PNU]"] = "[PNU]";
+    RiskEvidenceSynthesisUnitOfMeasure["Km"] = "km";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10.uN.s/cm2"] = "10.uN.s/cm2";
+    RiskEvidenceSynthesisUnitOfMeasure["[rd_br]"] = "[rd_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["%{OfWBCs}"] = "%{OfWBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Positive}"] = "%{Positive}";
+    RiskEvidenceSynthesisUnitOfMeasure["{RecTiter}"] = "{RecTiter}";
+    RiskEvidenceSynthesisUnitOfMeasure["/10*12{rbc}"] = "/10*12{rbc}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/mg{creat}"] = "ug/mg{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/mbar"] = "mL/mbar";
+    RiskEvidenceSynthesisUnitOfMeasure["U/10"] = "U/10";
+    RiskEvidenceSynthesisUnitOfMeasure["M[iU]"] = "m[iU]";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/kg"] = "umol/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["H/d"] = "h/d";
+    RiskEvidenceSynthesisUnitOfMeasure["{Can}"] = "{Can}";
+    RiskEvidenceSynthesisUnitOfMeasure["Cm2/s"] = "cm2/s";
+    RiskEvidenceSynthesisUnitOfMeasure["Dyn.s/cm"] = "dyn.s/cm";
+    RiskEvidenceSynthesisUnitOfMeasure["{Ehrlich'U}/(2.h)"] = "{Ehrlich'U}/(2.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Min/wk"] = "min/wk";
+    RiskEvidenceSynthesisUnitOfMeasure["G/kg/(8.h)"] = "g/kg/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["/mg"] = "/mg";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/s"] = "mL/s";
+    RiskEvidenceSynthesisUnitOfMeasure["%{saturation}"] = "%{saturation}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ph"] = "ph";
+    RiskEvidenceSynthesisUnitOfMeasure["L/kg"] = "L/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["KU"] = "kU";
+    RiskEvidenceSynthesisUnitOfMeasure["{delta_OD}"] = "{delta_OD}";
+    RiskEvidenceSynthesisUnitOfMeasure["Um"] = "um";
+    RiskEvidenceSynthesisUnitOfMeasure["Um/s"] = "um/s";
+    RiskEvidenceSynthesisUnitOfMeasure["[drp]/min"] = "[drp]/min";
+    RiskEvidenceSynthesisUnitOfMeasure["PA"] = "pA";
+    RiskEvidenceSynthesisUnitOfMeasure["[iU]/L"] = "[iU]/L";
+    RiskEvidenceSynthesisUnitOfMeasure["[syd_i]"] = "[syd_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/mg"] = "umol/mg";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Uptake}"] = "%{Uptake}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/g"] = "ug/g";
+    RiskEvidenceSynthesisUnitOfMeasure["{5 times}/d"] = "{5 times}/d";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/g{Hb}"] = "mU/g{Hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/h"] = "mg/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10.L/min"] = "10.L/min";
+    RiskEvidenceSynthesisUnitOfMeasure["[tbs_us]"] = "[tbs_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["/mm3"] = "/mm3";
+    RiskEvidenceSynthesisUnitOfMeasure["A_g"] = "a_g";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/g{Hgb}"] = "umol/g{Hgb}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/g{tissue}"] = "g/g{tissue}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{total}"] = "%{total}";
+    RiskEvidenceSynthesisUnitOfMeasure["{score}"] = "{score}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/mmol"] = "g/mmol";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/L"] = "[IU]/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Eq/L"] = "eq/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/(8.h.kg)"] = "meq/(8.h.kg)";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/mL"] = "pmol/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/kg/min"] = "mL/kg/min";
+    RiskEvidenceSynthesisUnitOfMeasure["M/s"] = "m/s";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/mmol{creat}"] = "pmol/mmol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mo_s"] = "mo_s";
+    RiskEvidenceSynthesisUnitOfMeasure["%"] = "%";
+    RiskEvidenceSynthesisUnitOfMeasure["Sph"] = "sph";
+    RiskEvidenceSynthesisUnitOfMeasure["G.m/{H.B.}"] = "g.m/{H.B.}";
+    RiskEvidenceSynthesisUnitOfMeasure["Kcal"] = "kcal";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/m2"] = "mg/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["{TSI_index}"] = "{TSI_index}";
+    RiskEvidenceSynthesisUnitOfMeasure["[cup_us]"] = "[cup_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["N.cm"] = "N.cm";
+    RiskEvidenceSynthesisUnitOfMeasure["U/10*12"] = "U/10*12";
+    RiskEvidenceSynthesisUnitOfMeasure["{dilution}"] = "{dilution}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/mL"] = "ug/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Mol/kg/s"] = "mol/kg/s";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/{total_volume}"] = "mg/{total_volume}";
+    RiskEvidenceSynthesisUnitOfMeasure["[Ch]"] = "[Ch]";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/{beat}/m2"] = "mL/{beat}/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]"] = "[IU]";
+    RiskEvidenceSynthesisUnitOfMeasure["{Beats}/min"] = "{Beats}/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/h"] = "umol/h";
+    RiskEvidenceSynthesisUnitOfMeasure["{Times}/wk"] = "{Times}/wk";
+    RiskEvidenceSynthesisUnitOfMeasure["Mm[H2O]"] = "mm[H2O]";
+    RiskEvidenceSynthesisUnitOfMeasure["Fmol/mg{cytosol_protein}"] = "fmol/mg{cytosol_protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{bound}"] = "%{bound}";
+    RiskEvidenceSynthesisUnitOfMeasure["[yd_i]"] = "[yd_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/kg/min"] = "mg/kg/min";
+    RiskEvidenceSynthesisUnitOfMeasure["R"] = "R";
+    RiskEvidenceSynthesisUnitOfMeasure["{Scoop}"] = "{Scoop}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/g{dry_wt}"] = "ug/g{dry_wt}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Tine'U}"] = "{Tine'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Elisa_U}/mL"] = "{Elisa_U}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["UCi"] = "uCi";
+    RiskEvidenceSynthesisUnitOfMeasure["U/mL{RBC}"] = "U/mL{RBC}";
+    RiskEvidenceSynthesisUnitOfMeasure["[ft_us]"] = "[ft_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["[bu_br]"] = "[bu_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["[in_i'Hg]"] = "[in_i'Hg]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/{Hgb}/g"] = "mg/{Hgb}/g";
+    RiskEvidenceSynthesisUnitOfMeasure["[dqt_us]"] = "[dqt_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["C"] = "C";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg{FEU}/L"] = "mg{FEU}/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*3.{RBC}"] = "10*3.{RBC}";
+    RiskEvidenceSynthesisUnitOfMeasure["B[uV]"] = "B[uV]";
+    RiskEvidenceSynthesisUnitOfMeasure["[m_e]"] = "[m_e]";
+    RiskEvidenceSynthesisUnitOfMeasure["{#}/a"] = "{#}/a";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/h/mg{prot}"] = "mmol/h/mg{prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["ms"] = "ms";
+    RiskEvidenceSynthesisUnitOfMeasure["{breaths}/min"] = "{breaths}/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Eq/umol"] = "eq/umol";
+    RiskEvidenceSynthesisUnitOfMeasure["Wk"] = "wk";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/{Specimen}"] = "meq/{Specimen}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/{total_vol}"] = "mmol/{total_vol}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{viable}"] = "%{viable}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/min"] = "umol/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Num24.h"] = "24.h";
+    RiskEvidenceSynthesisUnitOfMeasure["[dpt_us]"] = "[dpt_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/mol"] = "mmol/mol";
+    RiskEvidenceSynthesisUnitOfMeasure["{GPS'U}"] = "{GPS'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/m2"] = "meq/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["U/(1.h)"] = "U/(1.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["/L"] = "/L";
+    RiskEvidenceSynthesisUnitOfMeasure["/[arb'U]"] = "/[arb'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["[eps_0]"] = "[eps_0]";
+    RiskEvidenceSynthesisUnitOfMeasure["U[IU]/mL"] = "u[IU]/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Kcal/[oz_av]"] = "kcal/[oz_av]";
+    RiskEvidenceSynthesisUnitOfMeasure["F"] = "F";
+    RiskEvidenceSynthesisUnitOfMeasure["[ft_us]/[ft_us]"] = "[ft_us]/[ft_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["/dL"] = "/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["{STDV}"] = "{STDV}";
+    RiskEvidenceSynthesisUnitOfMeasure["{ELISA'U}"] = "{ELISA'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["Cal_th"] = "cal_th";
+    RiskEvidenceSynthesisUnitOfMeasure["G/d"] = "g/d";
+    RiskEvidenceSynthesisUnitOfMeasure["U/10*9"] = "U/10*9";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/mg{Cre}"] = "mU/mg{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["Circ"] = "circ";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/h/mg{prot}"] = "nmol/h/mg{prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["[ft_br]"] = "[ft_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["M[H2O]"] = "m[H2O]";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Binding}"] = "%{Binding}";
+    RiskEvidenceSynthesisUnitOfMeasure["/{Entity}"] = "/{Entity}";
+    RiskEvidenceSynthesisUnitOfMeasure["{HA_titer}"] = "{HA_titer}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(72.h)"] = "g/(72.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/mg{creat}"] = "[IU]/mg{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["L/(8.h)"] = "L/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["/uL"] = "/uL";
+    RiskEvidenceSynthesisUnitOfMeasure["UL/h"] = "uL/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Pkat"] = "pkat";
+    RiskEvidenceSynthesisUnitOfMeasure["{percentile}"] = "{percentile}";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/(24.h)"] = "pmol/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/d"] = "umol/d";
+    RiskEvidenceSynthesisUnitOfMeasure["Mo_g"] = "mo_g";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/L"] = "pmol/L";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/min/(173.10*Num2.m2)"] = "mL/min/(173.10*-2.m2)";
+    RiskEvidenceSynthesisUnitOfMeasure["[mil_us]"] = "[mil_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["{index_val}"] = "{index_val}";
+    RiskEvidenceSynthesisUnitOfMeasure["{JDF'U}/L"] = "{JDF'U}/L";
+    RiskEvidenceSynthesisUnitOfMeasure["UU/L"] = "uU/L";
+    RiskEvidenceSynthesisUnitOfMeasure["[srd_us]"] = "[srd_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/kg/h"] = "mg/kg/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6/kg"] = "10*6/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/{Tot'Volume}"] = "mmol/{Tot'Volume}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/h/L"] = "nmol/h/L";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/g"] = "[IU]/g";
+    RiskEvidenceSynthesisUnitOfMeasure["{Number}"] = "{Number}";
+    RiskEvidenceSynthesisUnitOfMeasure["Kcal/(8.h)"] = "kcal/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["MV/s"] = "mV/s";
+    RiskEvidenceSynthesisUnitOfMeasure["%{residual}"] = "%{residual}";
+    RiskEvidenceSynthesisUnitOfMeasure["Osm/kg"] = "osm/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["{KCT'U}"] = "{KCT'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["{ComplementCH100'U}"] = "{ComplementCH100'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["{minidrp}"] = "{minidrp}";
+    RiskEvidenceSynthesisUnitOfMeasure["/10*10"] = "/10*10";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/min/mL"] = "nmol/min/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/U"] = "ng/U";
+    RiskEvidenceSynthesisUnitOfMeasure["B"] = "B";
+    RiskEvidenceSynthesisUnitOfMeasure["{IgMAntiphosphatidyleserine'U}"] = "{IgMAntiphosphatidyleserine'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{HumanResponse}"] = "%{HumanResponse}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/{TotalWeight}"] = "g/{TotalWeight}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{recovery}"] = "%{recovery}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/s"] = "nmol/s";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/mmol{creatinine}"] = "mU/mmol{creatinine}";
+    RiskEvidenceSynthesisUnitOfMeasure["/g{HGB}"] = "/g{HGB}";
+    RiskEvidenceSynthesisUnitOfMeasure["U/10*10{cells}"] = "U/10*10{cells}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Streptozyme'U}"] = "{Streptozyme'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{penetration}"] = "%{penetration}";
+    RiskEvidenceSynthesisUnitOfMeasure["/cm[H2O]"] = "/cm[H2O]";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/d"] = "nmol/d";
+    RiskEvidenceSynthesisUnitOfMeasure["{IfaIndex}"] = "{IfaIndex}";
+    RiskEvidenceSynthesisUnitOfMeasure["G{total_nit}"] = "g{total_nit}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Cells}/uL"] = "{Cells}/uL";
+    RiskEvidenceSynthesisUnitOfMeasure["a"] = "a";
+    RiskEvidenceSynthesisUnitOfMeasure["U/dL"] = "U/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["G/kg/(8.h){shift}"] = "g/kg/(8.h){shift}";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/kg/d"] = "[IU]/kg/d";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/g{feces}"] = "ug/g{feces}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Count}"] = "{Count}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/s/L"] = "mmol/s/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*8"] = "10*8";
+    RiskEvidenceSynthesisUnitOfMeasure["{Pan_Bio'U}"] = "{Pan_Bio'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["[didot]"] = "[didot]";
+    RiskEvidenceSynthesisUnitOfMeasure["[bu_us]"] = "[bu_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ag/{cell}"] = "ag/{cell}";
+    RiskEvidenceSynthesisUnitOfMeasure["Cal"] = "cal";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Abnormal}"] = "%{Abnormal}";
+    RiskEvidenceSynthesisUnitOfMeasure["[qt_us]"] = "[qt_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/dL"] = "mL/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["{#}/g"] = "{#}/g";
+    RiskEvidenceSynthesisUnitOfMeasure["[diop]"] = "[diop]";
+    RiskEvidenceSynthesisUnitOfMeasure["[PFU]"] = "[PFU]";
+    RiskEvidenceSynthesisUnitOfMeasure["{copies}/ug"] = "{copies}/ug";
+    RiskEvidenceSynthesisUnitOfMeasure["Kg/L"] = "kg/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Torr"] = "Torr";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/mL{FEU}"] = "ug/mL{FEU}";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/d"] = "[IU]/d";
+    RiskEvidenceSynthesisUnitOfMeasure["[dye'U]"] = "[dye'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["Eq/mL"] = "eq/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/dL"] = "pmol/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["Bd"] = "Bd";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/g"] = "mU/g";
+    RiskEvidenceSynthesisUnitOfMeasure["[hd_i]"] = "[hd_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["{mm/dd/yyyy}"] = "{mm/dd/yyyy}";
+    RiskEvidenceSynthesisUnitOfMeasure["[pk_br]"] = "[pk_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["{# of informative markers}"] = "{# of informative markers}";
+    RiskEvidenceSynthesisUnitOfMeasure["Fg"] = "fg";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/kg/(8.h)"] = "ug/kg/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["MA"] = "mA";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/mg{Cre}"] = "umol/mg{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol{1/2cys}/mg{protein}"] = "nmol{1/2cys}/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["/10*12"] = "/10*12";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/g{protein}"] = "mU/g{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/dL{RBCs}"] = "mg/dL{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["[twp]"] = "[twp]";
+    RiskEvidenceSynthesisUnitOfMeasure["[TCID_50]"] = "[TCID_50]";
+    RiskEvidenceSynthesisUnitOfMeasure["[lb_ap]"] = "[lb_ap]";
+    RiskEvidenceSynthesisUnitOfMeasure["{2 or 3 times}/d"] = "{2 or 3 times}/d";
+    RiskEvidenceSynthesisUnitOfMeasure["Osm"] = "osm";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(3.d)"] = "g/(3.d)";
+    RiskEvidenceSynthesisUnitOfMeasure["/100{WBCs}"] = "/100{WBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/umol{creat}"] = "umol/umol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Cm2"] = "cm2";
+    RiskEvidenceSynthesisUnitOfMeasure["U/mmol{creat}"] = "U/mmol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(100.g)"] = "g/(100.g)";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/(2.h)"] = "umol/(2.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["G/kg/min"] = "g/kg/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Nm/s/L"] = "nm/s/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/h"] = "ng/h";
+    RiskEvidenceSynthesisUnitOfMeasure["G/g{creat}"] = "g/g{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["{EIA'U}"] = "{EIA'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Markers}"] = "{Markers}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Drinks}/d"] = "{Drinks}/d";
+    RiskEvidenceSynthesisUnitOfMeasure["{Log_IU}"] = "{Log_IU}";
+    RiskEvidenceSynthesisUnitOfMeasure["{CH100'U}"] = "{CH100'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/({h'b}.m2)"] = "mL/({h'b}.m2)";
+    RiskEvidenceSynthesisUnitOfMeasure["[iU]/g"] = "[iU]/g";
+    RiskEvidenceSynthesisUnitOfMeasure["L/(24.h)"] = "L/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["G/cm2"] = "g/cm2";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/g{dry_tissue}"] = "ug/g{dry_tissue}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mg"] = "nmol/mg";
+    RiskEvidenceSynthesisUnitOfMeasure["[drp]/s"] = "[drp]/s";
+    RiskEvidenceSynthesisUnitOfMeasure["%{OfLymphocytes}"] = "%{OfLymphocytes}";
+    RiskEvidenceSynthesisUnitOfMeasure["{copies}"] = "{copies}";
+    RiskEvidenceSynthesisUnitOfMeasure["U/kg/h"] = "U/kg/h";
+    RiskEvidenceSynthesisUnitOfMeasure["UL"] = "uL";
+    RiskEvidenceSynthesisUnitOfMeasure["[mi_br]"] = "[mi_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["{clock_time}"] = "{clock_time}";
+    RiskEvidenceSynthesisUnitOfMeasure["'"] = "'";
+    RiskEvidenceSynthesisUnitOfMeasure["/m2"] = "/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Carboxyhemoglobin}"] = "%{Carboxyhemoglobin}";
+    RiskEvidenceSynthesisUnitOfMeasure["[hp_Q]"] = "[hp_Q]";
+    RiskEvidenceSynthesisUnitOfMeasure["[c]"] = "[c]";
+    RiskEvidenceSynthesisUnitOfMeasure["G.m/({hb}.m2)"] = "g.m/({hb}.m2)";
+    RiskEvidenceSynthesisUnitOfMeasure["[mi_us]"] = "[mi_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["{RadioactiveT3UptakeRatio}"] = "{RadioactiveT3UptakeRatio}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/g{Hb}"] = "umol/g{Hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["P"] = "P";
+    RiskEvidenceSynthesisUnitOfMeasure["CP"] = "cP";
+    RiskEvidenceSynthesisUnitOfMeasure["[CCID_50]"] = "[CCID_50]";
+    RiskEvidenceSynthesisUnitOfMeasure["{IfaTiter}"] = "{IfaTiter}";
+    RiskEvidenceSynthesisUnitOfMeasure["[Amb'a'1'U]"] = "[Amb'a'1'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg{Phenylketones}/dL"] = "mg{Phenylketones}/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["[gil_us]"] = "[gil_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["{ImmuneStatusRatio}"] = "{ImmuneStatusRatio}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/L{rbc}"] = "umol/L{rbc}";
+    RiskEvidenceSynthesisUnitOfMeasure["[ly]"] = "[ly]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/(12.h)"] = "mmol/(12.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/mL"] = "meq/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["[MPL'U]/mL"] = "[MPL'U]/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/d"] = "mmol/d";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/{specimen}"] = "meq/{specimen}";
+    RiskEvidenceSynthesisUnitOfMeasure["[oz_tr]"] = "[oz_tr]";
+    RiskEvidenceSynthesisUnitOfMeasure["UV"] = "uV";
+    RiskEvidenceSynthesisUnitOfMeasure["[k]"] = "[k]";
+    RiskEvidenceSynthesisUnitOfMeasure["Pg/mL{sLT}"] = "pg/mL{sLT}";
+    RiskEvidenceSynthesisUnitOfMeasure["{DdTiter}"] = "{DdTiter}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Index}"] = "%{Index}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/min/mg{protein}"] = "nmol/min/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["{TmStp}"] = "{TmStp}";
+    RiskEvidenceSynthesisUnitOfMeasure["DaL/min/m2"] = "daL/min/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["/g{creat}"] = "/g{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["[rlk_us]"] = "[rlk_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/(100.g)"] = "ug/(100.g)";
+    RiskEvidenceSynthesisUnitOfMeasure["KL"] = "kL";
+    RiskEvidenceSynthesisUnitOfMeasure["{log_copies}/mL"] = "{log_copies}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6.[iU]"] = "10*6.[iU]";
+    RiskEvidenceSynthesisUnitOfMeasure["t"] = "t";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/{collection}"] = "mg/{collection}";
+    RiskEvidenceSynthesisUnitOfMeasure["Eq"] = "eq";
+    RiskEvidenceSynthesisUnitOfMeasure["U/s"] = "U/s";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(5.h)"] = "g/(5.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Us"] = "us";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/L/s"] = "mmol/L/s";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/{Volume}"] = "mg/{Volume}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/(8.h.kg)"] = "mmol/(8.h.kg)";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*3{RBCs}"] = "10*3{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["M[Hg]"] = "m[Hg]";
+    RiskEvidenceSynthesisUnitOfMeasure["NU/mL"] = "nU/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["[rch_us]"] = "[rch_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Kcal/d"] = "kcal/d";
+    RiskEvidenceSynthesisUnitOfMeasure["%{HemoglobinSaturation}"] = "%{HemoglobinSaturation}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Elisa'U}/mL"] = "{Elisa'U}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["/wk"] = "/wk";
+    RiskEvidenceSynthesisUnitOfMeasure["Cm/s"] = "cm/s";
+    RiskEvidenceSynthesisUnitOfMeasure["[pnt_pr]"] = "[pnt_pr]";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(4.h)"] = "g/(4.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{RBC}/uL"] = "{RBC}/uL";
+    RiskEvidenceSynthesisUnitOfMeasure["[CFU]/mL"] = "[CFU]/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["V"] = "V";
+    RiskEvidenceSynthesisUnitOfMeasure["U"] = "U";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/mmol{creat}"] = "mU/mmol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/{specimen}"] = "mg/{specimen}";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10.uN.s/cm"] = "10.uN.s/cm";
+    RiskEvidenceSynthesisUnitOfMeasure["{ThyroxinUptake'U}"] = "{ThyroxinUptake'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ohm"] = "Ohm";
+    RiskEvidenceSynthesisUnitOfMeasure["Eq/mmol"] = "eq/mmol";
+    RiskEvidenceSynthesisUnitOfMeasure["[bbl_us]"] = "[bbl_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["D/wk"] = "d/wk";
+    RiskEvidenceSynthesisUnitOfMeasure["G/g"] = "g/g";
+    RiskEvidenceSynthesisUnitOfMeasure["{NonspecificOunce}"] = "{NonspecificOunce}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/g{hemoglobin}"] = "umol/g{hemoglobin}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mL/h"] = "nmol/mL/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/10*6{RBC}"] = "umol/10*6{RBC}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Cound}"] = "%{Cound}";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq"] = "meq";
+    RiskEvidenceSynthesisUnitOfMeasure["ML{fetal_RBCs}"] = "mL{fetal_RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["[ch_us]"] = "[ch_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["{OpticalDensityRatio}"] = "{OpticalDensityRatio}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/cm3"] = "g/cm3";
+    RiskEvidenceSynthesisUnitOfMeasure["{beats}/min"] = "{beats}/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Bi"] = "Bi";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/dL"] = "[IU]/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["G/h/m2"] = "g/h/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/g"] = "umol/g";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/kg"] = "mmol/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["Cm3"] = "cm3";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/L"] = "mL/L";
+    RiskEvidenceSynthesisUnitOfMeasure["[mclg'U]"] = "[mclg'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/L{RBCs}"] = "ug/L{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["Cd"] = "cd";
+    RiskEvidenceSynthesisUnitOfMeasure["{Ehrlich'U}/d"] = "{Ehrlich'U}/d";
+    RiskEvidenceSynthesisUnitOfMeasure["[in_br]"] = "[in_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["{AHF'U}"] = "{AHF'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["[lton_av]"] = "[lton_av]";
+    RiskEvidenceSynthesisUnitOfMeasure["[bf_i]"] = "[bf_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["/10*4{RBCs}"] = "/10*4{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/(18.h)"] = "mg/(18.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Min/d"] = "min/d";
+    RiskEvidenceSynthesisUnitOfMeasure["[iU]/kg"] = "[iU]/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["{PackYears}"] = "{PackYears}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/mol{Cre}"] = "umol/mol{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/d/(173.10*Num2.m2)"] = "mg/d/(173.10*-2.m2)";
+    RiskEvidenceSynthesisUnitOfMeasure["[tb'U]"] = "[tb'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["Dm2/s2"] = "dm2/s2";
+    RiskEvidenceSynthesisUnitOfMeasure["U/10*10"] = "U/10*10";
+    RiskEvidenceSynthesisUnitOfMeasure["b"] = "b";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/(10.h)"] = "mL/(10.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/g"] = "mmol/g";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/m2"] = "ng/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/mg{creat}"] = "umol/mg{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["/{OIF}"] = "/{OIF}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/L/s"] = "nmol/L/s";
+    RiskEvidenceSynthesisUnitOfMeasure["[sft_i]"] = "[sft_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["/mL"] = "/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["%{ofBacteria}"] = "%{ofBacteria}";
+    RiskEvidenceSynthesisUnitOfMeasure["[min_us]"] = "[min_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6"] = "10*6";
+    RiskEvidenceSynthesisUnitOfMeasure["/mo"] = "/mo";
+    RiskEvidenceSynthesisUnitOfMeasure["Dyn.s/(cm.m2)"] = "dyn.s/(cm.m2)";
+    RiskEvidenceSynthesisUnitOfMeasure["/100{WBC}"] = "/100{WBC}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/[sft_i]"] = "ug/[sft_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["{CGG}"] = "{CGG}";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/g{Hb}"] = "[IU]/g{Hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*Num6{Immunofluorescence'U}"] = "10*-6{Immunofluorescence'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/10*6{RBCs}"] = "ng/10*6{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["[acr_br]"] = "[acr_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["Bit_s"] = "bit_s";
+    RiskEvidenceSynthesisUnitOfMeasure["MPa"] = "mPa";
+    RiskEvidenceSynthesisUnitOfMeasure["{StimulatingIndex}"] = "{StimulatingIndex}";
+    RiskEvidenceSynthesisUnitOfMeasure["[arb'U]/mL"] = "[arb'U]/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["[knk'U]"] = "[knk'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["Cel"] = "Cel";
+    RiskEvidenceSynthesisUnitOfMeasure["Pg/mm"] = "pg/mm";
+    RiskEvidenceSynthesisUnitOfMeasure["HL"] = "hL";
+    RiskEvidenceSynthesisUnitOfMeasure["UU/mL"] = "uU/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/(24.h)"] = "meq/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/(8.h)"] = "mg/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{Percentile}"] = "{Percentile}";
+    RiskEvidenceSynthesisUnitOfMeasure["{EhrlichU}/dL"] = "{EhrlichU}/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["%{positive}"] = "%{positive}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Absorbance'U}"] = "{Absorbance'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["[hp_C]"] = "[hp_C]";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(kg.min)"] = "g/(kg.min)";
+    RiskEvidenceSynthesisUnitOfMeasure["{Once}/d"] = "{Once}/d";
+    RiskEvidenceSynthesisUnitOfMeasure["{IgAPhospholipid'U}"] = "{IgAPhospholipid'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["{StandardIgM'U}"] = "{StandardIgM'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(8.kg.h)"] = "g/(8.kg.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/kg/min"] = "meq/kg/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/h/mg{Hb}"] = "mmol/h/mg{Hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["K/W"] = "K/W";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/(72.h)"] = "mg/(72.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[FFU]"] = "[FFU]";
+    RiskEvidenceSynthesisUnitOfMeasure["[arb'U]"] = "[arb'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mbar"] = "mbar";
+    RiskEvidenceSynthesisUnitOfMeasure["U/g{Hgb}"] = "U/g{Hgb}";
+    RiskEvidenceSynthesisUnitOfMeasure["{minidrop}/min"] = "{minidrop}/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/g{creat}"] = "meq/g{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["{#}/{platelet}"] = "{#}/{platelet}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Tot'Hgb}"] = "%{Tot'Hgb}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/mmol"] = "ug/mmol";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mg/h"] = "nmol/mg/h";
+    RiskEvidenceSynthesisUnitOfMeasure["[ft_i]"] = "[ft_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["g"] = "g";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/g{creat}"] = "mmol/g{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*4/uL"] = "10*4/uL";
+    RiskEvidenceSynthesisUnitOfMeasure["MCi"] = "mCi";
+    RiskEvidenceSynthesisUnitOfMeasure["[arb'U]/L"] = "[arb'U]/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Mm/min"] = "mm/min";
+    RiskEvidenceSynthesisUnitOfMeasure["{Capsule}"] = "{Capsule}";
+    RiskEvidenceSynthesisUnitOfMeasure["{StandardDeviation}"] = "{StandardDeviation}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Tot'Cholesterol}"] = "%{Tot'Cholesterol}";
+    RiskEvidenceSynthesisUnitOfMeasure["{ScoreOf}"] = "{ScoreOf}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{at_60_min}"] = "%{at_60_min}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/kg"] = "mg/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/umol"] = "umol/umol";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/d"] = "meq/d";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/h"] = "mL/h";
+    RiskEvidenceSynthesisUnitOfMeasure["MV"] = "MV";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6/mm3"] = "10*6/mm3";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/min"] = "mg/min";
+    RiskEvidenceSynthesisUnitOfMeasure["By"] = "By";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/min/mg{hemoglobin}"] = "nmol/min/mg{hemoglobin}";
+    RiskEvidenceSynthesisUnitOfMeasure["CL"] = "cL";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*3.U"] = "10*3.U";
+    RiskEvidenceSynthesisUnitOfMeasure["l"] = "l";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Oxygen}"] = "%{Oxygen}";
+    RiskEvidenceSynthesisUnitOfMeasure["U/g"] = "U/g";
+    RiskEvidenceSynthesisUnitOfMeasure["{IgMIndex}"] = "{IgMIndex}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/nmol"] = "nmol/nmol";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/kg/(8.h)"] = "mL/kg/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[smgy'U]"] = "[smgy'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["U[IU]"] = "u[IU]";
+    RiskEvidenceSynthesisUnitOfMeasure["[gr]"] = "[gr]";
+    RiskEvidenceSynthesisUnitOfMeasure["G/mol{creat}"] = "g/mol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["N"] = "N";
+    RiskEvidenceSynthesisUnitOfMeasure["{StdDeviation'U}"] = "{StdDeviation'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["NL"] = "nL";
+    RiskEvidenceSynthesisUnitOfMeasure["Cm[H2O]/s/m"] = "cm[H2O]/s/m";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol{BCE}/L"] = "nmol{BCE}/L";
+    RiskEvidenceSynthesisUnitOfMeasure["/U"] = "/U";
+    RiskEvidenceSynthesisUnitOfMeasure["Mol/s"] = "mol/s";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mL/min"] = "nmol/mL/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Mm/h"] = "mm/h";
+    RiskEvidenceSynthesisUnitOfMeasure["{s_co_ratio}"] = "{s_co_ratio}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Fat}"] = "%{Fat}";
+    RiskEvidenceSynthesisUnitOfMeasure["{kp_C}"] = "{kp_C}";
+    RiskEvidenceSynthesisUnitOfMeasure["u"] = "u";
+    RiskEvidenceSynthesisUnitOfMeasure["{spray}"] = "{spray}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/L{RBCs}"] = "mmol/L{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["[crd_us]"] = "[crd_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Cal_[20]"] = "cal_[20]";
+    RiskEvidenceSynthesisUnitOfMeasure["{lgCopies}/ml"] = "{lgCopies}/ml";
+    RiskEvidenceSynthesisUnitOfMeasure["/g{tot'prot}"] = "/g{tot'prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["[GPL'U]"] = "[GPL'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/kg/h"] = "ug/kg/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/(2.h)"] = "mg/(2.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{fraction}"] = "{fraction}";
+    RiskEvidenceSynthesisUnitOfMeasure["/g{tot'nit}"] = "/g{tot'nit}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/h/mL"] = "nmol/h/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["{Ct_value}"] = "{Ct_value}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/L"] = "nmol/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Kcal/(24.h)"] = "kcal/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/min"] = "meq/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/dL"] = "umol/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/(24.h)"] = "[IU]/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[gal_wi]"] = "[gal_wi]";
+    RiskEvidenceSynthesisUnitOfMeasure["[iU]/g{Hgb}"] = "[iU]/g{Hgb}";
+    RiskEvidenceSynthesisUnitOfMeasure["Pg/L"] = "pg/L";
+    RiskEvidenceSynthesisUnitOfMeasure["{molecule}/{platelet}"] = "{molecule}/{platelet}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/min/g{protein}"] = "umol/min/g{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/(24.h)"] = "ug/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["%{deficient}"] = "%{deficient}";
+    RiskEvidenceSynthesisUnitOfMeasure["A"] = "A";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/kg/(8.h)"] = "mmol/kg/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[pt_br]"] = "[pt_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["{clock time}"] = "{clock time}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/g{Cre}"] = "ng/g{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["{OD_unit}"] = "{OD_unit}";
+    RiskEvidenceSynthesisUnitOfMeasure["{CagRepeat}"] = "{CagRepeat}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{NormalPooledPlasma}"] = "%{NormalPooledPlasma}";
+    RiskEvidenceSynthesisUnitOfMeasure["[Btu_59]"] = "[Btu_59]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mol/d"] = "mol/d";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/g"] = "mg/g";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/(24.h)"] = "mg/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol"] = "nmol";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mL"] = "nmol/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/(8.h)"] = "ng/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/g{creat}"] = "ug/g{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["{#}/[HPF]"] = "{#}/[HPF]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/g{Cre}"] = "mg/g{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{FetalErythrocytes}"] = "%{FetalErythrocytes}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/dL{GF}"] = "nmol/dL{GF}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Absorbance'U}/mL"] = "{Absorbance'U}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["{ratio}"] = "{ratio}";
+    RiskEvidenceSynthesisUnitOfMeasure["Kg.m/s"] = "kg.m/s";
+    RiskEvidenceSynthesisUnitOfMeasure["{EIAIndex}"] = "{EIAIndex}";
+    RiskEvidenceSynthesisUnitOfMeasure["/mm"] = "/mm";
+    RiskEvidenceSynthesisUnitOfMeasure["{tot}"] = "{tot}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/mL/min"] = "umol/mL/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/dL"] = "nmol/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/mg{protein}"] = "pmol/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{EosSeen}"] = "%{EosSeen}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/dL"] = "ng/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["G/mol"] = "g/mol";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/mg{creat}"] = "ng/mg{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["/g{hgb}"] = "/g{hgb}";
+    RiskEvidenceSynthesisUnitOfMeasure["Gb"] = "Gb";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/h/L"] = "umol/h/L";
+    RiskEvidenceSynthesisUnitOfMeasure["%{normal_pooled_plasma}"] = "%{normal_pooled_plasma}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/s/L"] = "nmol/s/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/kg/h"] = "meq/kg/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/g{Hb}"] = "ug/g{Hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["/g{tot_nit}"] = "/g{tot_nit}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/min/g"] = "umol/min/g";
+    RiskEvidenceSynthesisUnitOfMeasure["{EIA_titer}"] = "{EIA_titer}";
+    RiskEvidenceSynthesisUnitOfMeasure["[kn_br]"] = "[kn_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/d"] = "pmol/d";
+    RiskEvidenceSynthesisUnitOfMeasure["{tbl}"] = "{tbl}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Hb}"] = "%{Hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/L/h"] = "umol/L/h";
+    RiskEvidenceSynthesisUnitOfMeasure["%{loss}"] = "%{loss}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mol/kg"] = "mol/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["{Ehrlich_U}/dL"] = "{Ehrlich_U}/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["G{wet_tissue}"] = "g{wet_tissue}";
+    RiskEvidenceSynthesisUnitOfMeasure["[sct]"] = "[sct]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/(kg.d)"] = "ng/(kg.d)";
+    RiskEvidenceSynthesisUnitOfMeasure["{Counts}/min"] = "{Counts}/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/kg{feces}"] = "umol/kg{feces}";
+    RiskEvidenceSynthesisUnitOfMeasure["[psi]"] = "[psi]";
+    RiskEvidenceSynthesisUnitOfMeasure["U/10*12{RBCs}"] = "U/10*12{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["/mmol"] = "/mmol";
+    RiskEvidenceSynthesisUnitOfMeasure["{SatIndex}"] = "{SatIndex}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/(8.h)"] = "ug/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["G/kg/h"] = "g/kg/h";
+    RiskEvidenceSynthesisUnitOfMeasure["{saturation}"] = "{saturation}";
+    RiskEvidenceSynthesisUnitOfMeasure["{CAE'U}"] = "{CAE'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["[stone_av]"] = "[stone_av]";
+    RiskEvidenceSynthesisUnitOfMeasure["U/mL{RBCs}"] = "U/mL{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*9/L"] = "10*9/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Kcal/h"] = "kcal/h";
+    RiskEvidenceSynthesisUnitOfMeasure["RAD"] = "RAD";
+    RiskEvidenceSynthesisUnitOfMeasure["Mosm/L"] = "mosm/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/min/mg{protein}"] = "pmol/min/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6/mL"] = "10*6/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["M3/s"] = "m3/s";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/h"] = "meq/h";
+    RiskEvidenceSynthesisUnitOfMeasure["{M.o.M.}"] = "{M.o.M.}";
+    RiskEvidenceSynthesisUnitOfMeasure["[pnt]"] = "[pnt]";
+    RiskEvidenceSynthesisUnitOfMeasure["{MultOfMean}"] = "{MultOfMean}";
+    RiskEvidenceSynthesisUnitOfMeasure["Kat/kg"] = "kat/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Normal}"] = "%{Normal}";
+    RiskEvidenceSynthesisUnitOfMeasure["{RPI'U}"] = "{RPI'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["{APS'U}"] = "{APS'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/{specimen}"] = "mmol/{specimen}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mol{creat}"] = "nmol/mol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["h"] = "h";
+    RiskEvidenceSynthesisUnitOfMeasure["/mmol{creat}"] = "/mmol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["{StandardIgA'U}"] = "{StandardIgA'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["{RelativeViscosity}"] = "{RelativeViscosity}";
+    RiskEvidenceSynthesisUnitOfMeasure["Pg/mg"] = "pg/mg";
+    RiskEvidenceSynthesisUnitOfMeasure["U/(10.g){feces}"] = "U/(10.g){feces}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/(8.h.kg)"] = "ng/(8.h.kg)";
+    RiskEvidenceSynthesisUnitOfMeasure["Lmb"] = "Lmb";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/L"] = "mmol/L";
+    RiskEvidenceSynthesisUnitOfMeasure["[ppb]"] = "[ppb]";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/kg/h"] = "mL/kg/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/mol"] = "pmol/mol";
+    RiskEvidenceSynthesisUnitOfMeasure["[CFU]/L"] = "[CFU]/L";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/10*9{RBCs}"] = "[IU]/10*9{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/s"] = "ng/s";
+    RiskEvidenceSynthesisUnitOfMeasure["[h]"] = "[h]";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(12.h)"] = "g/(12.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{Copies}/uL"] = "{Copies}/uL";
+    RiskEvidenceSynthesisUnitOfMeasure["Fmol/mg{prot}"] = "fmol/mg{prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["[pptr]"] = "[pptr]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/dL{RBCs}"] = "ug/dL{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["Atm"] = "atm";
+    RiskEvidenceSynthesisUnitOfMeasure["{Cell}"] = "{Cell}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/{TotalVolume}"] = "mg/{TotalVolume}";
+    RiskEvidenceSynthesisUnitOfMeasure["NCi"] = "nCi";
+    RiskEvidenceSynthesisUnitOfMeasure["[bdsk'U]"] = "[bdsk'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/min"] = "ug/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Num1/min"] = "1/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/g"] = "ng/g";
+    RiskEvidenceSynthesisUnitOfMeasure["{Patch}"] = "{Patch}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Activity}"] = "%{Activity}";
+    RiskEvidenceSynthesisUnitOfMeasure["[foz_br]"] = "[foz_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["A_j"] = "a_j";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/g{creat}"] = "ng/g{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["{#}/L"] = "{#}/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/mL"] = "ng/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/m2"] = "mL/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["[pied]"] = "[pied]";
+    RiskEvidenceSynthesisUnitOfMeasure["{Immunity}"] = "{Immunity}";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6.[CFU]/L"] = "10*6.[CFU]/L";
+    RiskEvidenceSynthesisUnitOfMeasure["D/(7.d)"] = "d/(7.d)";
+    RiskEvidenceSynthesisUnitOfMeasure["{Relative'U}"] = "{Relative'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/m2"] = "mmol/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/mg{cre}"] = "mg/mg{cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["U/(2.h)"] = "U/(2.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/d"] = "ug/d";
+    RiskEvidenceSynthesisUnitOfMeasure["[ppm]{v/v}"] = "[ppm]{v/v}";
+    RiskEvidenceSynthesisUnitOfMeasure["REM"] = "REM";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mmol"] = "nmol/mmol";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol{BCE}"] = "nmol{BCE}";
+    RiskEvidenceSynthesisUnitOfMeasure["[gil_br]"] = "[gil_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["[Lf]"] = "[Lf]";
+    RiskEvidenceSynthesisUnitOfMeasure["{shift}"] = "{shift}";
+    RiskEvidenceSynthesisUnitOfMeasure["/10*3{RBCs}"] = "/10*3{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/min/{1.73_m2}"] = "mL/min/{1.73_m2}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ar"] = "ar";
+    RiskEvidenceSynthesisUnitOfMeasure["G/(6.h)"] = "g/(6.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{MPS'U}/mL"] = "{MPS'U}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["G/dL"] = "g/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["U/(12.h)"] = "U/(12.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Kg"] = "kg";
+    RiskEvidenceSynthesisUnitOfMeasure["%{blocked}"] = "%{blocked}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/(8.h)"] = "umol/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*9/uL"] = "10*9/uL";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/h/mg{protein}"] = "mmol/h/mg{protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{uptake}"] = "%{uptake}";
+    RiskEvidenceSynthesisUnitOfMeasure["[pca_pr]"] = "[pca_pr]";
+    RiskEvidenceSynthesisUnitOfMeasure["%{reference}"] = "%{reference}";
+    RiskEvidenceSynthesisUnitOfMeasure["Cg"] = "cg";
+    RiskEvidenceSynthesisUnitOfMeasure["{#}/mL"] = "{#}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["{absorbance}"] = "{absorbance}";
+    RiskEvidenceSynthesisUnitOfMeasure["[sc_ap]"] = "[sc_ap]";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/min/m2"] = "mL/min/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Precipitate}"] = "%{Precipitate}";
+    RiskEvidenceSynthesisUnitOfMeasure["Osm/L"] = "osm/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/min/g{prot}"] = "umol/min/g{prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/m3"] = "ug/m3";
+    RiskEvidenceSynthesisUnitOfMeasure["{Ehrlich'U}"] = "{Ehrlich'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["U/L"] = "U/L";
+    RiskEvidenceSynthesisUnitOfMeasure["/s"] = "/s";
+    RiskEvidenceSynthesisUnitOfMeasure["[e]"] = "[e]";
+    RiskEvidenceSynthesisUnitOfMeasure["[fth_i]"] = "[fth_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["{Globules}/[HPF]"] = "{Globules}/[HPF]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/(24.h)"] = "ng/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Pc"] = "pc";
+    RiskEvidenceSynthesisUnitOfMeasure["{InhaledTobaccoUseAmountYears}"] = "{InhaledTobaccoUseAmountYears}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/mmol{urea}"] = "mmol/mmol{urea}";
+    RiskEvidenceSynthesisUnitOfMeasure["Sb"] = "sb";
+    RiskEvidenceSynthesisUnitOfMeasure["%{index}"] = "%{index}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mm"] = "mm";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*6.U"] = "10*6.U";
+    RiskEvidenceSynthesisUnitOfMeasure["Pmol/mmol"] = "pmol/mmol";
+    RiskEvidenceSynthesisUnitOfMeasure["[ch_br]"] = "[ch_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["DaL/min"] = "daL/min";
+    RiskEvidenceSynthesisUnitOfMeasure["[MET]"] = "[MET]";
+    RiskEvidenceSynthesisUnitOfMeasure["{activity}"] = "{activity}";
+    RiskEvidenceSynthesisUnitOfMeasure["[cml_i]"] = "[cml_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/(8.h)"] = "mmol/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{Lyme_index_value}"] = "{Lyme_index_value}";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/{ejaculate}"] = "mmol/{ejaculate}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Dilution}"] = "{Dilution}";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/kg/d"] = "mL/kg/d";
+    RiskEvidenceSynthesisUnitOfMeasure["Bar"] = "bar";
+    RiskEvidenceSynthesisUnitOfMeasure["W"] = "W";
+    RiskEvidenceSynthesisUnitOfMeasure["G/{specimen}"] = "g/{specimen}";
+    RiskEvidenceSynthesisUnitOfMeasure["[qt_br]"] = "[qt_br]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/mg/h"] = "ng/mg/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Np"] = "Np";
+    RiskEvidenceSynthesisUnitOfMeasure["N.s"] = "N.s";
+    RiskEvidenceSynthesisUnitOfMeasure["[mi_i]"] = "[mi_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/L"] = "umol/L";
+    RiskEvidenceSynthesisUnitOfMeasure["U/(18.h)"] = "U/(18.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{cells}/[HPF]"] = "{cells}/[HPF]";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Excretion}"] = "%{Excretion}";
+    RiskEvidenceSynthesisUnitOfMeasure["[foz_us]"] = "[foz_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/g{creat}"] = "nmol/g{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["{StandardIgG'U}"] = "{StandardIgG'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["[Btu_60]"] = "[Btu_60]";
+    RiskEvidenceSynthesisUnitOfMeasure["{InhaledTobaccoUsePacks}/d"] = "{InhaledTobaccoUsePacks}/d";
+    RiskEvidenceSynthesisUnitOfMeasure["G/h"] = "g/h";
+    RiskEvidenceSynthesisUnitOfMeasure["Min"] = "min";
+    RiskEvidenceSynthesisUnitOfMeasure["Pg"] = "pg";
+    RiskEvidenceSynthesisUnitOfMeasure["{ElisaIndex}"] = "{ElisaIndex}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{basal_activity}"] = "%{basal_activity}";
+    RiskEvidenceSynthesisUnitOfMeasure["G{Hb}"] = "g{Hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Zscore}"] = "{Zscore}";
+    RiskEvidenceSynthesisUnitOfMeasure["Pg/dL"] = "pg/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["Cal_IT"] = "cal_IT";
+    RiskEvidenceSynthesisUnitOfMeasure["%{cells}"] = "%{cells}";
+    RiskEvidenceSynthesisUnitOfMeasure["G/m2"] = "g/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Conversion}"] = "%{Conversion}";
+    RiskEvidenceSynthesisUnitOfMeasure["[cft_i]"] = "[cft_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/(8.h)"] = "meq/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["%{aggregation}"] = "%{aggregation}";
+    RiskEvidenceSynthesisUnitOfMeasure["L/min/m2"] = "L/min/m2";
+    RiskEvidenceSynthesisUnitOfMeasure["%{relative}"] = "%{relative}";
+    RiskEvidenceSynthesisUnitOfMeasure["{Disintegrations}/min"] = "{Disintegrations}/min";
+    RiskEvidenceSynthesisUnitOfMeasure["[mil_i]"] = "[mil_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/L{DDU}"] = "ug/L{DDU}";
+    RiskEvidenceSynthesisUnitOfMeasure["{ImmuneComplex'U}"] = "{ImmuneComplex'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{Reactivity}"] = "%{Reactivity}";
+    RiskEvidenceSynthesisUnitOfMeasure["U{G}"] = "U{G}";
+    RiskEvidenceSynthesisUnitOfMeasure["[yd_us]"] = "[yd_us]";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/(24.h)"] = "umol/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/kg/min"] = "ng/kg/min";
+    RiskEvidenceSynthesisUnitOfMeasure["%{activity}"] = "%{activity}";
+    RiskEvidenceSynthesisUnitOfMeasure["[todd'U]"] = "[todd'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/mmol{creat}"] = "umol/mmol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["[HP]"] = "[HP]";
+    RiskEvidenceSynthesisUnitOfMeasure["{Bowls}/d"] = "{Bowls}/d";
+    RiskEvidenceSynthesisUnitOfMeasure["D"] = "d";
+    RiskEvidenceSynthesisUnitOfMeasure["Nkat"] = "nkat";
+    RiskEvidenceSynthesisUnitOfMeasure["[oz_ap]"] = "[oz_ap]";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/(2.h)"] = "meq/(2.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{#}/uL"] = "{#}/uL";
+    RiskEvidenceSynthesisUnitOfMeasure["K[iU]/mL"] = "k[iU]/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["[pouce]"] = "[pouce]";
+    RiskEvidenceSynthesisUnitOfMeasure["/kg{body_wt}"] = "/kg{body_wt}";
+    RiskEvidenceSynthesisUnitOfMeasure["[Cal]"] = "[Cal]";
+    RiskEvidenceSynthesisUnitOfMeasure["Meq/g{Cre}"] = "meq/g{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{risk}"] = "%{risk}";
+    RiskEvidenceSynthesisUnitOfMeasure["[degF]"] = "[degF]";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/kg"] = "mL/kg";
+    RiskEvidenceSynthesisUnitOfMeasure["U/h"] = "U/h";
+    RiskEvidenceSynthesisUnitOfMeasure["G.m"] = "g.m";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/g{prot}"] = "mU/g{prot}";
+    RiskEvidenceSynthesisUnitOfMeasure["M[IU]/L"] = "m[IU]/L";
+    RiskEvidenceSynthesisUnitOfMeasure["{# of calculi}"] = "{# of calculi}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{dose}"] = "%{dose}";
+    RiskEvidenceSynthesisUnitOfMeasure["{TIBC'U}"] = "{TIBC'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["{relative_saturation}"] = "{relative_saturation}";
+    RiskEvidenceSynthesisUnitOfMeasure["Kg/min"] = "kg/min";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/L"] = "mU/L";
+    RiskEvidenceSynthesisUnitOfMeasure["{Ehrlich'U}/dL"] = "{Ehrlich'U}/dL";
+    RiskEvidenceSynthesisUnitOfMeasure["[cr_i]"] = "[cr_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["[beth'U]"] = "[beth'U]";
+    RiskEvidenceSynthesisUnitOfMeasure["{yyyy}"] = "{yyyy}";
+    RiskEvidenceSynthesisUnitOfMeasure["[hp_X]"] = "[hp_X]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/(24.h)"] = "mmol/(24.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["{Spermatozoa}/mL"] = "{Spermatozoa}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Mbar.s/L"] = "mbar.s/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/mg{Protein}"] = "ng/mg{Protein}";
+    RiskEvidenceSynthesisUnitOfMeasure["/100{Spermatozoa}"] = "/100{Spermatozoa}";
+    RiskEvidenceSynthesisUnitOfMeasure["{EV}"] = "{EV}";
+    RiskEvidenceSynthesisUnitOfMeasure["MU/mL"] = "mU/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/(12.h)"] = "mg/(12.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[MET].min/wk"] = "[MET].min/wk";
+    RiskEvidenceSynthesisUnitOfMeasure["{AspirinReaction'U}"] = "{AspirinReaction'U}";
+    RiskEvidenceSynthesisUnitOfMeasure["Kg/mol"] = "kg/mol";
+    RiskEvidenceSynthesisUnitOfMeasure["{cfu}/mL"] = "{cfu}/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Kg/m3"] = "kg/m3";
+    RiskEvidenceSynthesisUnitOfMeasure["Mm2"] = "mm2";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/mol{Hb}"] = "umol/mol{Hb}";
+    RiskEvidenceSynthesisUnitOfMeasure["ML/cm[H2O]"] = "mL/cm[H2O]";
+    RiskEvidenceSynthesisUnitOfMeasure["{EIA_index}"] = "{EIA_index}";
+    RiskEvidenceSynthesisUnitOfMeasure["U/d"] = "U/d";
+    RiskEvidenceSynthesisUnitOfMeasure["Fm"] = "fm";
+    RiskEvidenceSynthesisUnitOfMeasure["Cal_m"] = "cal_m";
+    RiskEvidenceSynthesisUnitOfMeasure["KU/L"] = "kU/L";
+    RiskEvidenceSynthesisUnitOfMeasure["S/{control}"] = "s/{control}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol{BCE}/mol"] = "umol{BCE}/mol";
+    RiskEvidenceSynthesisUnitOfMeasure["{GliadinIndexValue}"] = "{GliadinIndexValue}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/(kg.min)"] = "ng/(kg.min)";
+    RiskEvidenceSynthesisUnitOfMeasure["{Index_val}"] = "{Index_val}";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/mL"] = "[IU]/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["Ug/kg/min"] = "ug/kg/min";
+    RiskEvidenceSynthesisUnitOfMeasure["Deg/s"] = "deg/s";
+    RiskEvidenceSynthesisUnitOfMeasure["U[IU]/L"] = "u[IU]/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Mmol/mmol{creat}"] = "mmol/mmol{creat}";
+    RiskEvidenceSynthesisUnitOfMeasure["Umol/min/g{mucosa}"] = "umol/min/g{mucosa}";
+    RiskEvidenceSynthesisUnitOfMeasure["{DeltaOpticalDensity}"] = "{DeltaOpticalDensity}";
+    RiskEvidenceSynthesisUnitOfMeasure["{WeeksDays}"] = "{WeeksDays}";
+    RiskEvidenceSynthesisUnitOfMeasure["[pH]"] = "[pH]";
+    RiskEvidenceSynthesisUnitOfMeasure["Dyn"] = "dyn";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng"] = "ng";
+    RiskEvidenceSynthesisUnitOfMeasure["%{RBCs}"] = "%{RBCs}";
+    RiskEvidenceSynthesisUnitOfMeasure["Ng/kg/(8.h)"] = "ng/kg/(8.h)";
+    RiskEvidenceSynthesisUnitOfMeasure["[IU]/h"] = "[IU]/h";
+    RiskEvidenceSynthesisUnitOfMeasure["[mesh_i]"] = "[mesh_i]";
+    RiskEvidenceSynthesisUnitOfMeasure["[lne]"] = "[lne]";
+    RiskEvidenceSynthesisUnitOfMeasure["Mg/g{feces}"] = "mg/g{feces}";
+    RiskEvidenceSynthesisUnitOfMeasure["[dr_av]"] = "[dr_av]";
+    RiskEvidenceSynthesisUnitOfMeasure["{ActivityCoefficient}"] = "{ActivityCoefficient}";
+    RiskEvidenceSynthesisUnitOfMeasure["Nmol/mmol{Cre}"] = "nmol/mmol{Cre}";
+    RiskEvidenceSynthesisUnitOfMeasure["%{excretion}"] = "%{excretion}";
+    RiskEvidenceSynthesisUnitOfMeasure["L/L"] = "L/L";
+    RiskEvidenceSynthesisUnitOfMeasure["Num10*3/mL"] = "10*3/mL";
+    RiskEvidenceSynthesisUnitOfMeasure["PL"] = "pL";
+})(RiskEvidenceSynthesisUnitOfMeasure = exports.RiskEvidenceSynthesisUnitOfMeasure || (exports.RiskEvidenceSynthesisUnitOfMeasure = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Schedule.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Schedule.d.ts
index 93bf132..9aa3152 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Schedule.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Schedule.d.ts
@@ -8,6 +8,7 @@ import { Reference } from "./Reference";
 import { Identifier } from "./Identifier";
 /** A container for slots of time that may be available for booking appointments. */
 export interface Schedule extends DomainResource {
+    resourceType: 'Schedule';
     _active?: Element;
     /** High-level category */
     serviceCategory?: Array<CodeableConcept>;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SearchParameter.d.ts b/vendor/r4/types/hl7-fhir-r4-core/SearchParameter.d.ts
index cccb3d9..fb5e3e7 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SearchParameter.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/SearchParameter.d.ts
@@ -13,6 +13,7 @@ import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** A search parameter that defines a named search item that can be used to search/filter on a resource. */
 export interface SearchParameter extends DomainResource {
+    resourceType: 'SearchParameter';
     _base?: Array<Element>;
     /** Natural language description of the search parameter */
     description: markdown;
@@ -51,9 +52,9 @@ export interface SearchParameter extends DomainResource {
     xpath?: string;
     _xpathUsage?: Element;
     /** normal | phonetic | nearby | distance | other */
-    xpathUsage?: code;
+    xpathUsage?: `${SearchParameterXpathUsage}`;
     /** number | date | string | token | reference | composite | quantity | uri | special */
-    type: code;
+    type: `${SearchParameterType}`;
     /** For testing purposes, not real usage */
     experimental?: boolean;
     /** For Composite resources to define the parts */
@@ -62,7 +63,7 @@ export interface SearchParameter extends DomainResource {
     _description?: Element;
     _purpose?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${SearchParameterStatus}`;
     _target?: Array<Element>;
     _name?: Element;
     /** Chained names supported */
@@ -88,6 +89,26 @@ export interface SearchParameter extends DomainResource {
     _url?: Element;
     _multipleAnd?: Element;
 }
+/** normal | phonetic | nearby | distance | other */
+export declare enum SearchParameterXpathUsage {
+    Distance = "distance",
+    Nearby = "nearby",
+    Normal = "normal",
+    Other = "other",
+    Phonetic = "phonetic"
+}
+/** number | date | string | token | reference | composite | quantity | uri | special */
+export declare enum SearchParameterType {
+    Uri = "uri",
+    Number = "number",
+    Date = "date",
+    Special = "special",
+    Quantity = "quantity",
+    String = "string",
+    Composite = "composite",
+    Token = "token",
+    Reference = "reference"
+}
 /** For Composite resources to define the parts */
 export interface SearchParameterComponent extends BackboneElement {
     /** Defines how the part works */
@@ -97,3 +118,10 @@ export interface SearchParameterComponent extends BackboneElement {
     expression: string;
     _expression?: Element;
 }
+/** draft | active | retired | unknown */
+export declare enum SearchParameterStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SearchParameter.js b/vendor/r4/types/hl7-fhir-r4-core/SearchParameter.js
index c8ad2e5..2f801e1 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SearchParameter.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/SearchParameter.js
@@ -1,2 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchParameterStatus = exports.SearchParameterType = exports.SearchParameterXpathUsage = void 0;
+/** normal | phonetic | nearby | distance | other */
+var SearchParameterXpathUsage;
+(function (SearchParameterXpathUsage) {
+    SearchParameterXpathUsage["Distance"] = "distance";
+    SearchParameterXpathUsage["Nearby"] = "nearby";
+    SearchParameterXpathUsage["Normal"] = "normal";
+    SearchParameterXpathUsage["Other"] = "other";
+    SearchParameterXpathUsage["Phonetic"] = "phonetic";
+})(SearchParameterXpathUsage = exports.SearchParameterXpathUsage || (exports.SearchParameterXpathUsage = {}));
+/** number | date | string | token | reference | composite | quantity | uri | special */
+var SearchParameterType;
+(function (SearchParameterType) {
+    SearchParameterType["Uri"] = "uri";
+    SearchParameterType["Number"] = "number";
+    SearchParameterType["Date"] = "date";
+    SearchParameterType["Special"] = "special";
+    SearchParameterType["Quantity"] = "quantity";
+    SearchParameterType["String"] = "string";
+    SearchParameterType["Composite"] = "composite";
+    SearchParameterType["Token"] = "token";
+    SearchParameterType["Reference"] = "reference";
+})(SearchParameterType = exports.SearchParameterType || (exports.SearchParameterType = {}));
+/** draft | active | retired | unknown */
+var SearchParameterStatus;
+(function (SearchParameterStatus) {
+    SearchParameterStatus["Active"] = "active";
+    SearchParameterStatus["Draft"] = "draft";
+    SearchParameterStatus["Retired"] = "retired";
+    SearchParameterStatus["Unknown"] = "unknown";
+})(SearchParameterStatus = exports.SearchParameterStatus || (exports.SearchParameterStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ServiceRequest.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ServiceRequest.d.ts
index 463aae0..33f3fa6 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ServiceRequest.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ServiceRequest.d.ts
@@ -13,10 +13,10 @@ import { DomainResource } from "./DomainResource";
 import { Ratio } from "./Ratio";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** A record of a request for service such as diagnostic investigations, treatments, or operations to be performed. */
 export interface ServiceRequest extends DomainResource {
+    resourceType: 'ServiceRequest';
     /** Performer role */
     performerType?: CodeableConcept;
     /** Classification of service */
@@ -34,7 +34,7 @@ export interface ServiceRequest extends DomainResource {
     /** Additional clinical information */
     supportingInfo?: Array<Reference>;
     /** Encounter in which the request was created */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     /** Patient or consumer-oriented instructions */
     patientInstruction?: string;
     _doNotPerform?: Element;
@@ -57,12 +57,12 @@ export interface ServiceRequest extends DomainResource {
     /** Requested location */
     locationReference?: Array<Reference>;
     /** Who/what is requesting service */
-    requester?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    requester?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** routine | urgent | asap | stat */
-    priority?: code;
+    priority?: `${ServiceRequestPriority}`;
     occurrencePeriod?: Period;
     /** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
-    status: code;
+    status: `${ServiceRequestStatus}`;
     quantityRatio?: Ratio;
     /** What is being requested/ordered */
     code?: CodeableConcept;
@@ -73,7 +73,7 @@ export interface ServiceRequest extends DomainResource {
     /** Location on Body */
     bodySite?: Array<CodeableConcept>;
     /** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
-    intent: code;
+    intent: `${ServiceRequestIntent}`;
     quantityRange?: Range;
     quantityQuantity?: Quantity;
     /** What request replaces */
@@ -87,7 +87,7 @@ export interface ServiceRequest extends DomainResource {
     occurrenceDateTime?: dateTime;
     _instantiatesCanonical?: Array<Element>;
     /** Individual or Entity the service is ordered for */
-    subject: Reference<"Patient" | "Device" | "Location" | "Group">;
+    subject: Reference<'Patient' | 'Device' | 'Location' | 'Group'>;
     asNeededCodeableConcept?: CodeableConcept;
     /** Requested performer */
     performer?: Array<Reference>;
@@ -96,3 +96,32 @@ export interface ServiceRequest extends DomainResource {
     _instantiatesUri?: Array<Element>;
     _occurrenceDateTime?: Element;
 }
+/** routine | urgent | asap | stat */
+export declare enum ServiceRequestPriority {
+    Asap = "asap",
+    Routine = "routine",
+    Stat = "stat",
+    Urgent = "urgent"
+}
+/** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
+export declare enum ServiceRequestStatus {
+    Active = "active",
+    Completed = "completed",
+    Draft = "draft",
+    EnteredInError = "entered-in-error",
+    OnHold = "on-hold",
+    Revoked = "revoked",
+    Unknown = "unknown"
+}
+/** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
+export declare enum ServiceRequestIntent {
+    Order = "order",
+    FillerOrder = "filler-order",
+    Option = "option",
+    Directive = "directive",
+    Proposal = "proposal",
+    ReflexOrder = "reflex-order",
+    Plan = "plan",
+    InstanceOrder = "instance-order",
+    OriginalOrder = "original-order"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ServiceRequest.js b/vendor/r4/types/hl7-fhir-r4-core/ServiceRequest.js
index c8ad2e5..31bd1df 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ServiceRequest.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ServiceRequest.js
@@ -1,2 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceRequestIntent = exports.ServiceRequestStatus = exports.ServiceRequestPriority = void 0;
+/** routine | urgent | asap | stat */
+var ServiceRequestPriority;
+(function (ServiceRequestPriority) {
+    ServiceRequestPriority["Asap"] = "asap";
+    ServiceRequestPriority["Routine"] = "routine";
+    ServiceRequestPriority["Stat"] = "stat";
+    ServiceRequestPriority["Urgent"] = "urgent";
+})(ServiceRequestPriority = exports.ServiceRequestPriority || (exports.ServiceRequestPriority = {}));
+/** draft | active | on-hold | revoked | completed | entered-in-error | unknown */
+var ServiceRequestStatus;
+(function (ServiceRequestStatus) {
+    ServiceRequestStatus["Active"] = "active";
+    ServiceRequestStatus["Completed"] = "completed";
+    ServiceRequestStatus["Draft"] = "draft";
+    ServiceRequestStatus["EnteredInError"] = "entered-in-error";
+    ServiceRequestStatus["OnHold"] = "on-hold";
+    ServiceRequestStatus["Revoked"] = "revoked";
+    ServiceRequestStatus["Unknown"] = "unknown";
+})(ServiceRequestStatus = exports.ServiceRequestStatus || (exports.ServiceRequestStatus = {}));
+/** proposal | plan | directive | order | original-order | reflex-order | filler-order | instance-order | option */
+var ServiceRequestIntent;
+(function (ServiceRequestIntent) {
+    ServiceRequestIntent["Order"] = "order";
+    ServiceRequestIntent["FillerOrder"] = "filler-order";
+    ServiceRequestIntent["Option"] = "option";
+    ServiceRequestIntent["Directive"] = "directive";
+    ServiceRequestIntent["Proposal"] = "proposal";
+    ServiceRequestIntent["ReflexOrder"] = "reflex-order";
+    ServiceRequestIntent["Plan"] = "plan";
+    ServiceRequestIntent["InstanceOrder"] = "instance-order";
+    ServiceRequestIntent["OriginalOrder"] = "original-order";
+})(ServiceRequestIntent = exports.ServiceRequestIntent || (exports.ServiceRequestIntent = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Signature.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Signature.d.ts
index 1c43964..a02e5e1 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Signature.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Signature.d.ts
@@ -5,25 +5,38 @@ import { base64Binary } from "./base64Binary";
 import { instant } from "./instant";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 /** Base StructureDefinition for Signature Type: A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities. */
 export interface Signature extends Element {
     /** Who signed */
-    who: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    who: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     _data?: Element;
     /** When the signature was created */
     when: instant;
     /** The party represented */
-    onBehalfOf?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    onBehalfOf?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     _sigFormat?: Element;
     _targetFormat?: Element;
     /** The technical format of the signature */
-    sigFormat?: code;
+    sigFormat?: `${SignatureSigFormat}`;
     /** Indication of the reason the entity signed the object(s) */
     type: Array<Coding>;
     /** The technical format of the signed resources */
-    targetFormat?: code;
+    targetFormat?: `${SignatureTargetFormat}`;
     _when?: Element;
     /** The actual signature content (XML DigSig. JWS, picture, etc.) */
     data?: base64Binary;
 }
+/** The technical format of the signature */
+export declare enum SignatureSigFormat {
+    "Application/hl7Cda+xml" = "application/hl7-cda+xml",
+    "Application/sparqlResults+xml" = "application/sparql-results+xml",
+    "Application/sql" = "application/sql",
+    "Application/xquery" = "application/xquery"
+}
+/** The technical format of the signed resources */
+export declare enum SignatureTargetFormat {
+    "Application/hl7Cda+xml" = "application/hl7-cda+xml",
+    "Application/sparqlResults+xml" = "application/sparql-results+xml",
+    "Application/sql" = "application/sql",
+    "Application/xquery" = "application/xquery"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Signature.js b/vendor/r4/types/hl7-fhir-r4-core/Signature.js
index c8ad2e5..63d95d4 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Signature.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Signature.js
@@ -1,2 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureTargetFormat = exports.SignatureSigFormat = void 0;
+/** The technical format of the signature */
+var SignatureSigFormat;
+(function (SignatureSigFormat) {
+    SignatureSigFormat["Application/hl7Cda+xml"] = "application/hl7-cda+xml";
+    SignatureSigFormat["Application/sparqlResults+xml"] = "application/sparql-results+xml";
+    SignatureSigFormat["Application/sql"] = "application/sql";
+    SignatureSigFormat["Application/xquery"] = "application/xquery";
+})(SignatureSigFormat = exports.SignatureSigFormat || (exports.SignatureSigFormat = {}));
+/** The technical format of the signed resources */
+var SignatureTargetFormat;
+(function (SignatureTargetFormat) {
+    SignatureTargetFormat["Application/hl7Cda+xml"] = "application/hl7-cda+xml";
+    SignatureTargetFormat["Application/sparqlResults+xml"] = "application/sparql-results+xml";
+    SignatureTargetFormat["Application/sql"] = "application/sql";
+    SignatureTargetFormat["Application/xquery"] = "application/xquery";
+})(SignatureTargetFormat = exports.SignatureTargetFormat || (exports.SignatureTargetFormat = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Slot.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Slot.d.ts
index b0a80e4..8153135 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Slot.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Slot.d.ts
@@ -5,12 +5,12 @@ import { DomainResource } from "./DomainResource";
 import { instant } from "./instant";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 /** A slot of time on a schedule that may be available for booking appointments. */
 export interface Slot extends DomainResource {
+    resourceType: 'Slot';
     /** The schedule resource that this slot defines an interval of status information */
-    schedule: Reference<"Schedule">;
+    schedule: Reference<'Schedule'>;
     /** A broad categorization of the service that is to be performed during this appointment */
     serviceCategory?: Array<CodeableConcept>;
     /** The specialty of a practitioner that would be required to perform the service requested in this appointment */
@@ -24,7 +24,7 @@ export interface Slot extends DomainResource {
     /** The style of appointment or patient that may be booked in the slot (not service type) */
     appointmentType?: CodeableConcept;
     /** busy | free | busy-unavailable | busy-tentative | entered-in-error */
-    status: code;
+    status: `${SlotStatus}`;
     /** Comments on the slot to describe any extended information. Such as custom constraints on the slot */
     comment?: string;
     /** External Ids for this item */
@@ -37,3 +37,11 @@ export interface Slot extends DomainResource {
     /** This slot has already been overbooked, appointments are unlikely to be accepted for this time */
     overbooked?: boolean;
 }
+/** busy | free | busy-unavailable | busy-tentative | entered-in-error */
+export declare enum SlotStatus {
+    Busy = "busy",
+    BusyTentative = "busy-tentative",
+    BusyUnavailable = "busy-unavailable",
+    EnteredInError = "entered-in-error",
+    Free = "free"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Slot.js b/vendor/r4/types/hl7-fhir-r4-core/Slot.js
index c8ad2e5..594958c 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Slot.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Slot.js
@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotStatus = void 0;
+/** busy | free | busy-unavailable | busy-tentative | entered-in-error */
+var SlotStatus;
+(function (SlotStatus) {
+    SlotStatus["Busy"] = "busy";
+    SlotStatus["BusyTentative"] = "busy-tentative";
+    SlotStatus["BusyUnavailable"] = "busy-unavailable";
+    SlotStatus["EnteredInError"] = "entered-in-error";
+    SlotStatus["Free"] = "free";
+})(SlotStatus = exports.SlotStatus || (exports.SlotStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Specimen.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Specimen.d.ts
index 2d4cd90..f455d61 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Specimen.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Specimen.d.ts
@@ -9,11 +9,11 @@ import { Duration } from "./Duration";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A sample to be used for analysis. */
 export interface Specimen extends DomainResource {
+    resourceType: 'Specimen';
     /** Why the specimen was collected */
     request?: Array<Reference>;
     /** The time when specimen was received for processing */
@@ -28,7 +28,7 @@ export interface Specimen extends DomainResource {
     /** Comments */
     note?: Array<Annotation>;
     /** available | unavailable | unsatisfactory | entered-in-error */
-    status?: code;
+    status?: `${SpecimenStatus}`;
     /** State of the specimen */
     condition?: Array<CodeableConcept>;
     /** Direct container of specimen (tube/slide, etc.) */
@@ -41,7 +41,7 @@ export interface Specimen extends DomainResource {
     /** Collection details */
     collection?: SpecimenCollection;
     /** Where the specimen came from. This may be from patient(s), from a location (e.g., the source of an environmental sample), or a sampling of a substance or a device */
-    subject?: Reference<"Patient" | "Device" | "Location" | "Substance" | "Group">;
+    subject?: Reference<'Patient' | 'Device' | 'Location' | 'Substance' | 'Group'>;
 }
 /** Processing and processing step details */
 export interface SpecimenProcessing extends BackboneElement {
@@ -56,6 +56,13 @@ export interface SpecimenProcessing extends BackboneElement {
     _timeDateTime?: Element;
     timePeriod?: Period;
 }
+/** available | unavailable | unsatisfactory | entered-in-error */
+export declare enum SpecimenStatus {
+    Available = "available",
+    EnteredInError = "entered-in-error",
+    Unavailable = "unavailable",
+    Unsatisfactory = "unsatisfactory"
+}
 /** Direct container of specimen (tube/slide, etc.) */
 export interface SpecimenContainer extends BackboneElement {
     /** Textual description of the container */
@@ -70,7 +77,7 @@ export interface SpecimenContainer extends BackboneElement {
     additiveCodeableConcept?: CodeableConcept;
     /** Id for the container */
     identifier?: Array<Identifier>;
-    additiveReference?: Reference<"Substance">;
+    additiveReference?: Reference<'Substance'>;
 }
 /** Collection details */
 export interface SpecimenCollection extends BackboneElement {
@@ -82,7 +89,7 @@ export interface SpecimenCollection extends BackboneElement {
     /** How long it took to collect specimen */
     duration?: Duration;
     /** Who collected the specimen */
-    collector?: Reference<"PractitionerRole" | "Practitioner">;
+    collector?: Reference<'PractitionerRole' | 'Practitioner'>;
     _collectedDateTime?: Element;
     /** Anatomical collection site */
     bodySite?: CodeableConcept;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Specimen.js b/vendor/r4/types/hl7-fhir-r4-core/Specimen.js
index c8ad2e5..c51e3ce 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Specimen.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Specimen.js
@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecimenStatus = void 0;
+/** available | unavailable | unsatisfactory | entered-in-error */
+var SpecimenStatus;
+(function (SpecimenStatus) {
+    SpecimenStatus["Available"] = "available";
+    SpecimenStatus["EnteredInError"] = "entered-in-error";
+    SpecimenStatus["Unavailable"] = "unavailable";
+    SpecimenStatus["Unsatisfactory"] = "unsatisfactory";
+})(SpecimenStatus = exports.SpecimenStatus || (exports.SpecimenStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SpecimenDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/SpecimenDefinition.d.ts
index a23a6cd..87835ea 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SpecimenDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/SpecimenDefinition.d.ts
@@ -8,11 +8,11 @@ import { Duration } from "./Duration";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A kind of specimen with associated set of requirements. */
 export interface SpecimenDefinition extends DomainResource {
+    resourceType: 'SpecimenDefinition';
     /** Business identifier of a kind of specimen */
     identifier?: Identifier;
     /** Kind of material to collect */
@@ -27,6 +27,11 @@ export interface SpecimenDefinition extends DomainResource {
     /** Specimen in container intended for testing by lab */
     typeTested?: Array<SpecimenDefinitionTypeTested>;
 }
+/** preferred | alternate */
+export declare enum SpecimenDefinitionPreference {
+    Alternate = "alternate",
+    Preferred = "preferred"
+}
 /** Specimen handling before testing */
 export interface SpecimenDefinitionHandling extends BackboneElement {
     /** Temperature qualifier */
@@ -42,7 +47,7 @@ export interface SpecimenDefinitionHandling extends BackboneElement {
 /** Additive associated with container */
 export interface SpecimenDefinitionAdditive extends BackboneElement {
     additiveCodeableConcept: CodeableConcept;
-    additiveReference: Reference<"Substance">;
+    additiveReference: Reference<'Substance'>;
 }
 /** The specimen's container */
 export interface SpecimenDefinitionContainer extends BackboneElement {
@@ -81,7 +86,7 @@ export interface SpecimenDefinitionTypeTested extends BackboneElement {
     /** Rejection criterion */
     rejectionCriterion?: Array<CodeableConcept>;
     /** preferred | alternate */
-    preference: code;
+    preference: `${SpecimenDefinitionPreference}`;
     /** Specimen handling before testing */
     handling?: Array<SpecimenDefinitionHandling>;
     /** The specimen's container */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SpecimenDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/SpecimenDefinition.js
index c8ad2e5..5fd86e1 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SpecimenDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/SpecimenDefinition.js
@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecimenDefinitionPreference = void 0;
+/** preferred | alternate */
+var SpecimenDefinitionPreference;
+(function (SpecimenDefinitionPreference) {
+    SpecimenDefinitionPreference["Alternate"] = "alternate";
+    SpecimenDefinitionPreference["Preferred"] = "preferred";
+})(SpecimenDefinitionPreference = exports.SpecimenDefinitionPreference || (exports.SpecimenDefinitionPreference = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/StructureDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/StructureDefinition.d.ts
index 08f512a..7be88a9 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/StructureDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/StructureDefinition.d.ts
@@ -12,24 +12,24 @@ import { ElementDefinition } from "./ElementDefinition";
 import { DomainResource } from "./DomainResource";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types. */
 export interface StructureDefinition extends DomainResource {
+    resourceType: 'StructureDefinition';
     /** Natural language description of the structure definition */
     description?: markdown;
     _kind?: Element;
     /** Date last changed */
     date?: dateTime;
     /** specialization | constraint - How relates to base definition */
-    derivation?: code;
+    derivation?: `${StructureDefinitionDerivation}`;
     /** Name of the publisher (organization or individual) */
     publisher?: string;
     /** FHIRPath invariants - when the extension can be used */
     contextInvariant?: Array<string>;
     /** FHIR Version this StructureDefinition targets */
-    fhirVersion?: code;
+    fhirVersion?: `${StructureDefinitionFhirVersion}`;
     /** Intended jurisdiction for structure definition (if applicable) */
     jurisdiction?: Array<CodeableConcept>;
     _publisher?: Element;
@@ -64,9 +64,9 @@ export interface StructureDefinition extends DomainResource {
     /** Assist with indexing and finding */
     keyword?: Array<Coding>;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${StructureDefinitionStatus}`;
     /** primitive-type | complex-type | resource | logical */
-    kind: code;
+    kind: `${StructureDefinitionKind}`;
     _name?: Element;
     /** Canonical identifier for this structure definition, represented as a URI (globally unique) */
     url: uri;
@@ -90,37 +90,87 @@ export interface StructureDefinition extends DomainResource {
     /** Definition that this type is constrained/specialized from */
     baseDefinition?: canonical;
 }
-/** External specification that the content is mapped to */
-export interface StructureDefinitionMapping extends BackboneElement {
-    /** Internal id when this mapping is used */
-    identity: id;
-    _identity?: Element;
-    /** Identifies what this mapping refers to */
-    uri?: uri;
-    _uri?: Element;
-    /** Names what this mapping refers to */
-    name?: string;
-    _name?: Element;
-    /** Versions, Issues, Scope limitations etc. */
-    comment?: string;
-    _comment?: Element;
+/** specialization | constraint - How relates to base definition */
+export declare enum StructureDefinitionDerivation {
+    Constraint = "constraint",
+    Specialization = "specialization"
 }
-/** Snapshot view of the structure */
-export interface StructureDefinitionSnapshot extends BackboneElement {
+/** Differential view of the structure */
+export interface StructureDefinitionDifferential extends BackboneElement {
     /** Definition of elements in the resource (if no StructureDefinition) */
     element: Array<ElementDefinition>;
 }
 /** If an extension, where it can be used in instances */
 export interface StructureDefinitionContext extends BackboneElement {
     /** fhirpath | element | extension */
-    type: code;
+    type: `${StructureDefinitionType}`;
     _type?: Element;
     /** Where the extension can be used in instances */
     expression: string;
     _expression?: Element;
 }
-/** Differential view of the structure */
-export interface StructureDefinitionDifferential extends BackboneElement {
+/** primitive-type | complex-type | resource | logical */
+export declare enum StructureDefinitionKind {
+    ComplexType = "complex-type",
+    Logical = "logical",
+    PrimitiveType = "primitive-type",
+    Resource = "resource"
+}
+/** FHIR Version this StructureDefinition targets */
+export declare enum StructureDefinitionFhirVersion {
+    "Num1.8.0" = "1.8.0",
+    "Num0.05" = "0.05",
+    "Num0.01" = "0.01",
+    "Num3.0.1" = "3.0.1",
+    "Num1.0.0" = "1.0.0",
+    "Num3.3.0" = "3.3.0",
+    "Num0.0.82" = "0.0.82",
+    "Num1.6.0" = "1.6.0",
+    "Num1.4.0" = "1.4.0",
+    "Num3.0.0" = "3.0.0",
+    "Num0.0.80" = "0.0.80",
+    "Num4.0.0" = "4.0.0",
+    "Num0.11" = "0.11",
+    "Num0.06" = "0.06",
+    "Num1.0.2" = "1.0.2",
+    "Num1.0.1" = "1.0.1",
+    "Num0.4.0" = "0.4.0",
+    "Num4.0.1" = "4.0.1",
+    "Num3.5.0" = "3.5.0",
+    "Num0.5.0" = "0.5.0",
+    "Num1.1.0" = "1.1.0",
+    "Num0.0.81" = "0.0.81"
+}
+/** fhirpath | element | extension */
+export declare enum StructureDefinitionType {
+    Element = "element",
+    Extension = "extension",
+    Fhirpath = "fhirpath"
+}
+/** Snapshot view of the structure */
+export interface StructureDefinitionSnapshot extends BackboneElement {
     /** Definition of elements in the resource (if no StructureDefinition) */
     element: Array<ElementDefinition>;
 }
+/** draft | active | retired | unknown */
+export declare enum StructureDefinitionStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** External specification that the content is mapped to */
+export interface StructureDefinitionMapping extends BackboneElement {
+    /** Internal id when this mapping is used */
+    identity: id;
+    _identity?: Element;
+    /** Identifies what this mapping refers to */
+    uri?: uri;
+    _uri?: Element;
+    /** Names what this mapping refers to */
+    name?: string;
+    _name?: Element;
+    /** Versions, Issues, Scope limitations etc. */
+    comment?: string;
+    _comment?: Element;
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/StructureDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/StructureDefinition.js
index c8ad2e5..7e5574a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/StructureDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/StructureDefinition.js
@@ -1,2 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructureDefinitionStatus = exports.StructureDefinitionType = exports.StructureDefinitionFhirVersion = exports.StructureDefinitionKind = exports.StructureDefinitionDerivation = void 0;
+/** specialization | constraint - How relates to base definition */
+var StructureDefinitionDerivation;
+(function (StructureDefinitionDerivation) {
+    StructureDefinitionDerivation["Constraint"] = "constraint";
+    StructureDefinitionDerivation["Specialization"] = "specialization";
+})(StructureDefinitionDerivation = exports.StructureDefinitionDerivation || (exports.StructureDefinitionDerivation = {}));
+/** primitive-type | complex-type | resource | logical */
+var StructureDefinitionKind;
+(function (StructureDefinitionKind) {
+    StructureDefinitionKind["ComplexType"] = "complex-type";
+    StructureDefinitionKind["Logical"] = "logical";
+    StructureDefinitionKind["PrimitiveType"] = "primitive-type";
+    StructureDefinitionKind["Resource"] = "resource";
+})(StructureDefinitionKind = exports.StructureDefinitionKind || (exports.StructureDefinitionKind = {}));
+/** FHIR Version this StructureDefinition targets */
+var StructureDefinitionFhirVersion;
+(function (StructureDefinitionFhirVersion) {
+    StructureDefinitionFhirVersion["Num1.8.0"] = "1.8.0";
+    StructureDefinitionFhirVersion["Num0.05"] = "0.05";
+    StructureDefinitionFhirVersion["Num0.01"] = "0.01";
+    StructureDefinitionFhirVersion["Num3.0.1"] = "3.0.1";
+    StructureDefinitionFhirVersion["Num1.0.0"] = "1.0.0";
+    StructureDefinitionFhirVersion["Num3.3.0"] = "3.3.0";
+    StructureDefinitionFhirVersion["Num0.0.82"] = "0.0.82";
+    StructureDefinitionFhirVersion["Num1.6.0"] = "1.6.0";
+    StructureDefinitionFhirVersion["Num1.4.0"] = "1.4.0";
+    StructureDefinitionFhirVersion["Num3.0.0"] = "3.0.0";
+    StructureDefinitionFhirVersion["Num0.0.80"] = "0.0.80";
+    StructureDefinitionFhirVersion["Num4.0.0"] = "4.0.0";
+    StructureDefinitionFhirVersion["Num0.11"] = "0.11";
+    StructureDefinitionFhirVersion["Num0.06"] = "0.06";
+    StructureDefinitionFhirVersion["Num1.0.2"] = "1.0.2";
+    StructureDefinitionFhirVersion["Num1.0.1"] = "1.0.1";
+    StructureDefinitionFhirVersion["Num0.4.0"] = "0.4.0";
+    StructureDefinitionFhirVersion["Num4.0.1"] = "4.0.1";
+    StructureDefinitionFhirVersion["Num3.5.0"] = "3.5.0";
+    StructureDefinitionFhirVersion["Num0.5.0"] = "0.5.0";
+    StructureDefinitionFhirVersion["Num1.1.0"] = "1.1.0";
+    StructureDefinitionFhirVersion["Num0.0.81"] = "0.0.81";
+})(StructureDefinitionFhirVersion = exports.StructureDefinitionFhirVersion || (exports.StructureDefinitionFhirVersion = {}));
+/** fhirpath | element | extension */
+var StructureDefinitionType;
+(function (StructureDefinitionType) {
+    StructureDefinitionType["Element"] = "element";
+    StructureDefinitionType["Extension"] = "extension";
+    StructureDefinitionType["Fhirpath"] = "fhirpath";
+})(StructureDefinitionType = exports.StructureDefinitionType || (exports.StructureDefinitionType = {}));
+/** draft | active | retired | unknown */
+var StructureDefinitionStatus;
+(function (StructureDefinitionStatus) {
+    StructureDefinitionStatus["Active"] = "active";
+    StructureDefinitionStatus["Draft"] = "draft";
+    StructureDefinitionStatus["Retired"] = "retired";
+    StructureDefinitionStatus["Unknown"] = "unknown";
+})(StructureDefinitionStatus = exports.StructureDefinitionStatus || (exports.StructureDefinitionStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/StructureMap.d.ts b/vendor/r4/types/hl7-fhir-r4-core/StructureMap.d.ts
index fff32b7..8c4894b 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/StructureMap.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/StructureMap.d.ts
@@ -53,6 +53,7 @@ import { decimal } from "./decimal";
 import { Contributor } from "./Contributor";
 /** A Map of relationships between 2 structures that can be used to transform data. */
 export interface StructureMap extends DomainResource {
+    resourceType: 'StructureMap';
     /** Natural language description of the structure map */
     description?: markdown;
     /** Date last changed */
@@ -85,7 +86,7 @@ export interface StructureMap extends DomainResource {
     /** Structure Definition used by this map */
     structure?: Array<StructureMapStructure>;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${StructureMapStatus}`;
     _name?: Element;
     /** Canonical identifier for this structure map, represented as a URI (globally unique) */
     url: uri;
@@ -102,38 +103,40 @@ export interface StructureMap extends DomainResource {
     contact?: Array<ContactDetail>;
     _url?: Element;
 }
-/** Named instance provided when invoking the map */
-export interface StructureMapInput extends BackboneElement {
-    /** Name for this instance of data */
-    name: id;
-    _name?: Element;
-    /** Type for this instance of data */
-    type?: string;
-    _type?: Element;
-    /** source | target */
-    mode: code;
-    _mode?: Element;
-    /** Documentation for this instance of data */
-    documentation?: string;
-    _documentation?: Element;
+/** Content to create because of this mapping rule */
+export interface StructureMapGroupRuleTarget extends BackboneElement {
+    /** create | copy + */
+    transform?: `${StructureMapGroupRuleTransform}`;
+    /** Named context for field, if desired, and a field is specified */
+    variable?: id;
+    /** Field to create in the context */
+    element?: string;
+    /** Internal rule reference for shared list items */
+    listRuleId?: id;
+    _transform?: Element;
+    /** Type or variable this rule applies to */
+    context?: id;
+    _element?: Element;
+    /** first | share | last | collate */
+    listMode?: Array<code>;
+    _listRuleId?: Element;
+    _listMode?: Array<Element>;
+    _contextType?: Element;
+    /** type | variable */
+    contextType?: `${StructureMapGroupRuleContextType}`;
+    _variable?: Element;
+    /** Parameters to the transform */
+    parameter?: Array<StructureMapGroupRuleParameter>;
+    _context?: Element;
 }
-/** Named sections for reader convenience */
-export interface StructureMapGroup extends BackboneElement {
-    _documentation?: Element;
-    /** Another group that this group adds rules to */
-    extends?: id;
-    _extends?: Element;
-    /** none | types | type-and-types */
-    typeMode: code;
-    /** Human-readable label */
+/** Which other rules to apply in the context of this rule */
+export interface StructureMapGroupRuleDependent extends BackboneElement {
+    /** Name of a rule or group to apply */
     name: id;
-    rule: Array<StructureMapGroupRule>;
-    _typeMode?: Element;
-    /** Additional description/explanation for group */
-    documentation?: string;
     _name?: Element;
-    /** Named instance provided when invoking the map */
-    input: Array<StructureMapInput>;
+    /** Variable to pass to the rule or group */
+    variable: Array<string>;
+    _variable?: Array<Element>;
 }
 /** Structure Definition used by this map */
 export interface StructureMapStructure extends BackboneElement {
@@ -141,7 +144,7 @@ export interface StructureMapStructure extends BackboneElement {
     url: canonical;
     _url?: Element;
     /** source | queried | target | produced */
-    mode: code;
+    mode: `${StructureMapMode}`;
     _mode?: Element;
     /** Name for type in this map */
     alias?: string;
@@ -150,6 +153,34 @@ export interface StructureMapStructure extends BackboneElement {
     documentation?: string;
     _documentation?: Element;
 }
+/** Parameters to the transform */
+export interface StructureMapGroupRuleParameter extends BackboneElement {
+    _valueBoolean: Element;
+    _valueId: Element;
+    valueDecimal: decimal;
+    _valueDecimal: Element;
+    _valueString: Element;
+    valueString: string;
+    valueBoolean: boolean;
+    valueInteger: integer;
+    valueId: id;
+    _valueInteger: Element;
+}
+/** Named instance provided when invoking the map */
+export interface StructureMapInput extends BackboneElement {
+    /** Name for this instance of data */
+    name: id;
+    _name?: Element;
+    /** Type for this instance of data */
+    type?: string;
+    _type?: Element;
+    /** source | target */
+    mode: `${StructureMapMode}`;
+    _mode?: Element;
+    /** Documentation for this instance of data */
+    documentation?: string;
+    _documentation?: Element;
+}
 /** Source inputs to the mapping */
 export interface StructureMapGroupRuleSource extends BackboneElement {
     defaultValueTime?: time;
@@ -236,7 +267,7 @@ export interface StructureMapGroupRuleSource extends BackboneElement {
     _defaultValueDateTime?: Element;
     defaultValueUsageContext?: UsageContext;
     /** first | not_first | last | not_last | only_one */
-    listMode?: code;
+    listMode?: `${StructureMapGroupRuleListMode}`;
     defaultValueParameterDefinition?: ParameterDefinition;
     _listMode?: Element;
     defaultValueDateTime?: dateTime;
@@ -252,53 +283,29 @@ export interface StructureMapGroupRuleSource extends BackboneElement {
     _defaultValueDate?: Element;
     _context?: Element;
 }
-/** Parameters to the transform */
-export interface StructureMapGroupRuleParameter extends BackboneElement {
-    _valueBoolean: Element;
-    _valueId: Element;
-    valueDecimal: decimal;
-    _valueDecimal: Element;
-    _valueString: Element;
-    valueString: string;
-    valueBoolean: boolean;
-    valueInteger: integer;
-    valueId: id;
-    _valueInteger: Element;
-}
-/** Content to create because of this mapping rule */
-export interface StructureMapGroupRuleTarget extends BackboneElement {
-    /** create | copy + */
-    transform?: code;
-    /** Named context for field, if desired, and a field is specified */
-    variable?: id;
-    /** Field to create in the context */
-    element?: string;
-    /** Internal rule reference for shared list items */
-    listRuleId?: id;
-    _transform?: Element;
-    /** Type or variable this rule applies to */
-    context?: id;
-    _element?: Element;
-    /** first | share | last | collate */
-    listMode?: Array<code>;
-    _listRuleId?: Element;
-    _listMode?: Array<Element>;
-    _contextType?: Element;
-    /** type | variable */
-    contextType?: code;
-    _variable?: Element;
-    /** Parameters to the transform */
-    parameter?: Array<StructureMapGroupRuleParameter>;
-    _context?: Element;
-}
-/** Which other rules to apply in the context of this rule */
-export interface StructureMapGroupRuleDependent extends BackboneElement {
-    /** Name of a rule or group to apply */
+/** Named sections for reader convenience */
+export interface StructureMapGroup extends BackboneElement {
+    _documentation?: Element;
+    /** Another group that this group adds rules to */
+    extends?: id;
+    _extends?: Element;
+    /** none | types | type-and-types */
+    typeMode: `${StructureMapTypeMode}`;
+    /** Human-readable label */
     name: id;
+    rule: Array<StructureMapGroupRule>;
+    _typeMode?: Element;
+    /** Additional description/explanation for group */
+    documentation?: string;
     _name?: Element;
-    /** Variable to pass to the rule or group */
-    variable: Array<string>;
-    _variable?: Array<Element>;
+    /** Named instance provided when invoking the map */
+    input: Array<StructureMapInput>;
+}
+/** none | types | type-and-types */
+export declare enum StructureMapTypeMode {
+    None = "none",
+    TypeAndTypes = "type-and-types",
+    Types = "types"
 }
 /** Transform Rule from source to target */
 export interface StructureMapGroupRule extends BackboneElement {
@@ -317,3 +324,50 @@ export interface StructureMapGroupRule extends BackboneElement {
     documentation?: string;
     _documentation?: Element;
 }
+/** create | copy + */
+export declare enum StructureMapGroupRuleTransform {
+    Copy = "copy",
+    Cast = "cast",
+    Cp = "cp",
+    Append = "append",
+    Uuid = "uuid",
+    Pointer = "pointer",
+    Evaluate = "evaluate",
+    Qty = "qty",
+    Cc = "cc",
+    C = "c",
+    Escape = "escape",
+    Truncate = "truncate",
+    Translate = "translate",
+    Create = "create",
+    DateOp = "dateOp",
+    Reference = "reference",
+    Id = "id"
+}
+/** draft | active | retired | unknown */
+export declare enum StructureMapStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** first | not_first | last | not_last | only_one */
+export declare enum StructureMapGroupRuleListMode {
+    First = "first",
+    Last = "last",
+    "Not_first" = "not_first",
+    "Not_last" = "not_last",
+    "Only_one" = "only_one"
+}
+/** type | variable */
+export declare enum StructureMapGroupRuleContextType {
+    Type = "type",
+    Variable = "variable"
+}
+/** source | queried | target | produced */
+export declare enum StructureMapMode {
+    Produced = "produced",
+    Queried = "queried",
+    Source = "source",
+    Target = "target"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/StructureMap.js b/vendor/r4/types/hl7-fhir-r4-core/StructureMap.js
index c8ad2e5..4e7f089 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/StructureMap.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/StructureMap.js
@@ -1,2 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructureMapMode = exports.StructureMapGroupRuleContextType = exports.StructureMapGroupRuleListMode = exports.StructureMapStatus = exports.StructureMapGroupRuleTransform = exports.StructureMapTypeMode = void 0;
+/** none | types | type-and-types */
+var StructureMapTypeMode;
+(function (StructureMapTypeMode) {
+    StructureMapTypeMode["None"] = "none";
+    StructureMapTypeMode["TypeAndTypes"] = "type-and-types";
+    StructureMapTypeMode["Types"] = "types";
+})(StructureMapTypeMode = exports.StructureMapTypeMode || (exports.StructureMapTypeMode = {}));
+/** create | copy + */
+var StructureMapGroupRuleTransform;
+(function (StructureMapGroupRuleTransform) {
+    StructureMapGroupRuleTransform["Copy"] = "copy";
+    StructureMapGroupRuleTransform["Cast"] = "cast";
+    StructureMapGroupRuleTransform["Cp"] = "cp";
+    StructureMapGroupRuleTransform["Append"] = "append";
+    StructureMapGroupRuleTransform["Uuid"] = "uuid";
+    StructureMapGroupRuleTransform["Pointer"] = "pointer";
+    StructureMapGroupRuleTransform["Evaluate"] = "evaluate";
+    StructureMapGroupRuleTransform["Qty"] = "qty";
+    StructureMapGroupRuleTransform["Cc"] = "cc";
+    StructureMapGroupRuleTransform["C"] = "c";
+    StructureMapGroupRuleTransform["Escape"] = "escape";
+    StructureMapGroupRuleTransform["Truncate"] = "truncate";
+    StructureMapGroupRuleTransform["Translate"] = "translate";
+    StructureMapGroupRuleTransform["Create"] = "create";
+    StructureMapGroupRuleTransform["DateOp"] = "dateOp";
+    StructureMapGroupRuleTransform["Reference"] = "reference";
+    StructureMapGroupRuleTransform["Id"] = "id";
+})(StructureMapGroupRuleTransform = exports.StructureMapGroupRuleTransform || (exports.StructureMapGroupRuleTransform = {}));
+/** draft | active | retired | unknown */
+var StructureMapStatus;
+(function (StructureMapStatus) {
+    StructureMapStatus["Active"] = "active";
+    StructureMapStatus["Draft"] = "draft";
+    StructureMapStatus["Retired"] = "retired";
+    StructureMapStatus["Unknown"] = "unknown";
+})(StructureMapStatus = exports.StructureMapStatus || (exports.StructureMapStatus = {}));
+/** first | not_first | last | not_last | only_one */
+var StructureMapGroupRuleListMode;
+(function (StructureMapGroupRuleListMode) {
+    StructureMapGroupRuleListMode["First"] = "first";
+    StructureMapGroupRuleListMode["Last"] = "last";
+    StructureMapGroupRuleListMode["Not_first"] = "not_first";
+    StructureMapGroupRuleListMode["Not_last"] = "not_last";
+    StructureMapGroupRuleListMode["Only_one"] = "only_one";
+})(StructureMapGroupRuleListMode = exports.StructureMapGroupRuleListMode || (exports.StructureMapGroupRuleListMode = {}));
+/** type | variable */
+var StructureMapGroupRuleContextType;
+(function (StructureMapGroupRuleContextType) {
+    StructureMapGroupRuleContextType["Type"] = "type";
+    StructureMapGroupRuleContextType["Variable"] = "variable";
+})(StructureMapGroupRuleContextType = exports.StructureMapGroupRuleContextType || (exports.StructureMapGroupRuleContextType = {}));
+/** source | queried | target | produced */
+var StructureMapMode;
+(function (StructureMapMode) {
+    StructureMapMode["Produced"] = "produced";
+    StructureMapMode["Queried"] = "queried";
+    StructureMapMode["Source"] = "source";
+    StructureMapMode["Target"] = "target";
+})(StructureMapMode = exports.StructureMapMode || (exports.StructureMapMode = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Subscription.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Subscription.d.ts
index c4336e6..790cec9 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Subscription.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Subscription.d.ts
@@ -5,10 +5,10 @@ import { ContactPoint } from "./ContactPoint";
 import { DomainResource } from "./DomainResource";
 import { instant } from "./instant";
 import { Element } from "./Element";
-import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** The subscription resource is used to define a push-based subscription from a server to another system. Once a subscription is registered with the server, the server checks every resource that is created or updated, and if the resource matches the given criteria, it sends a message on the defined "channel" so that another system can take an appropriate action. */
 export interface Subscription extends DomainResource {
+    resourceType: 'Subscription';
     _end?: Element;
     /** Rule for server push */
     criteria: string;
@@ -19,7 +19,7 @@ export interface Subscription extends DomainResource {
     /** Description of why this subscription was created */
     reason: string;
     /** requested | active | error | off */
-    status: code;
+    status: `${SubscriptionStatus}`;
     _reason?: Element;
     /** Latest error note */
     error?: string;
@@ -29,18 +29,40 @@ export interface Subscription extends DomainResource {
     /** Contact details for source (e.g. troubleshooting) */
     contact?: Array<ContactPoint>;
 }
+/** rest-hook | websocket | email | sms | message */
+export declare enum SubscriptionType {
+    Email = "email",
+    Message = "message",
+    RestHook = "rest-hook",
+    Sms = "sms",
+    Websocket = "websocket"
+}
+/** MIME type to send, or omit for no payload */
+export declare enum SubscriptionPayload {
+    "Application/hl7Cda+xml" = "application/hl7-cda+xml",
+    "Application/sparqlResults+xml" = "application/sparql-results+xml",
+    "Application/sql" = "application/sql",
+    "Application/xquery" = "application/xquery"
+}
 /** The channel on which to report matches to the criteria */
 export interface SubscriptionChannel extends BackboneElement {
     /** rest-hook | websocket | email | sms | message */
-    type: code;
+    type: `${SubscriptionType}`;
     _type?: Element;
     /** Where the channel points to */
     endpoint?: url;
     _endpoint?: Element;
     /** MIME type to send, or omit for no payload */
-    payload?: code;
+    payload?: `${SubscriptionPayload}`;
     _payload?: Element;
     /** Usage depends on the channel type */
     header?: Array<string>;
     _header?: Array<Element>;
 }
+/** requested | active | error | off */
+export declare enum SubscriptionStatus {
+    Active = "active",
+    Error = "error",
+    Off = "off",
+    Requested = "requested"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Subscription.js b/vendor/r4/types/hl7-fhir-r4-core/Subscription.js
index c8ad2e5..e846add 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Subscription.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Subscription.js
@@ -1,2 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionStatus = exports.SubscriptionPayload = exports.SubscriptionType = void 0;
+/** rest-hook | websocket | email | sms | message */
+var SubscriptionType;
+(function (SubscriptionType) {
+    SubscriptionType["Email"] = "email";
+    SubscriptionType["Message"] = "message";
+    SubscriptionType["RestHook"] = "rest-hook";
+    SubscriptionType["Sms"] = "sms";
+    SubscriptionType["Websocket"] = "websocket";
+})(SubscriptionType = exports.SubscriptionType || (exports.SubscriptionType = {}));
+/** MIME type to send, or omit for no payload */
+var SubscriptionPayload;
+(function (SubscriptionPayload) {
+    SubscriptionPayload["Application/hl7Cda+xml"] = "application/hl7-cda+xml";
+    SubscriptionPayload["Application/sparqlResults+xml"] = "application/sparql-results+xml";
+    SubscriptionPayload["Application/sql"] = "application/sql";
+    SubscriptionPayload["Application/xquery"] = "application/xquery";
+})(SubscriptionPayload = exports.SubscriptionPayload || (exports.SubscriptionPayload = {}));
+/** requested | active | error | off */
+var SubscriptionStatus;
+(function (SubscriptionStatus) {
+    SubscriptionStatus["Active"] = "active";
+    SubscriptionStatus["Error"] = "error";
+    SubscriptionStatus["Off"] = "off";
+    SubscriptionStatus["Requested"] = "requested";
+})(SubscriptionStatus = exports.SubscriptionStatus || (exports.SubscriptionStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Substance.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Substance.d.ts
index c01b132..85be3c1 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Substance.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Substance.d.ts
@@ -7,11 +7,11 @@ import { DomainResource } from "./DomainResource";
 import { Ratio } from "./Ratio";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A homogeneous material with a definite composition. */
 export interface Substance extends DomainResource {
+    resourceType: 'Substance';
     /** Textual description of the substance, comments */
     description?: string;
     /** What class/type of substance this is */
@@ -23,7 +23,7 @@ export interface Substance extends DomainResource {
     /** Composition information about the substance */
     ingredient?: Array<SubstanceIngredient>;
     /** active | inactive | entered-in-error */
-    status?: code;
+    status?: `${SubstanceStatus}`;
     /** What substance this is */
     code: CodeableConcept;
     /** Unique identifier */
@@ -44,5 +44,11 @@ export interface SubstanceIngredient extends BackboneElement {
     /** Optional amount (concentration) */
     quantity?: Ratio;
     substanceCodeableConcept: CodeableConcept;
-    substanceReference: Reference<"Substance">;
+    substanceReference: Reference<'Substance'>;
+}
+/** active | inactive | entered-in-error */
+export declare enum SubstanceStatus {
+    Active = "active",
+    EnteredInError = "entered-in-error",
+    Inactive = "inactive"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Substance.js b/vendor/r4/types/hl7-fhir-r4-core/Substance.js
index c8ad2e5..c024c41 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Substance.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Substance.js
@@ -1,2 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubstanceStatus = void 0;
+/** active | inactive | entered-in-error */
+var SubstanceStatus;
+(function (SubstanceStatus) {
+    SubstanceStatus["Active"] = "active";
+    SubstanceStatus["EnteredInError"] = "entered-in-error";
+    SubstanceStatus["Inactive"] = "inactive";
+})(SubstanceStatus = exports.SubstanceStatus || (exports.SubstanceStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SubstanceNucleicAcid.d.ts b/vendor/r4/types/hl7-fhir-r4-core/SubstanceNucleicAcid.d.ts
index cd7f741..5030289 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SubstanceNucleicAcid.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/SubstanceNucleicAcid.d.ts
@@ -9,6 +9,7 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Nucleic acids are defined by three distinct elements: the base, sugar and linkage. Individual substance/moiety IDs will be created for each of these elements. The nucleotide sequence will be always entered in the 5’-3’ direction. */
 export interface SubstanceNucleicAcid extends DomainResource {
+    resourceType: 'SubstanceNucleicAcid';
     /** The type of the sequence shall be specified based on a controlled vocabulary */
     sequenceType?: CodeableConcept;
     /** The number of linear sequences of nucleotides linked through phosphodiester bonds shall be described. Subunits would be strands of nucleic acids that are tightly associated typically through Watson-Crick base pairing. NOTE: If not specified in the reference source, the assumption is that there is 1 subunit */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SubstancePolymer.d.ts b/vendor/r4/types/hl7-fhir-r4-core/SubstancePolymer.d.ts
index 38bb7ce..e3a6c12 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SubstancePolymer.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/SubstancePolymer.d.ts
@@ -9,6 +9,7 @@ import { Element } from "./Element";
 import { BackboneElement } from "./BackboneElement";
 /** Todo. */
 export interface SubstancePolymer extends DomainResource {
+    resourceType: 'SubstancePolymer';
     /** Todo */
     class?: CodeableConcept;
     /** Todo */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SubstanceProtein.d.ts b/vendor/r4/types/hl7-fhir-r4-core/SubstanceProtein.d.ts
index 91a1dac..91bef94 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SubstanceProtein.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/SubstanceProtein.d.ts
@@ -9,6 +9,7 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A SubstanceProtein is defined as a single unit of a linear amino acid sequence, or a combination of subunits that are either covalently linked or have a defined invariant stoichiometric relationship. This includes all synthetic, recombinant and purified SubstanceProteins of defined sequence, whether the use is therapeutic or prophylactic. This set of elements will be used to describe albumins, coagulation factors, cytokines, growth factors, peptide/SubstanceProtein hormones, enzymes, toxins, toxoids, recombinant vaccines, and immunomodulators. */
 export interface SubstanceProtein extends DomainResource {
+    resourceType: 'SubstanceProtein';
     /** The SubstanceProtein descriptive elements will only be used when a complete or partial amino acid sequence is available or derivable from a nucleic acid sequence */
     sequenceType?: CodeableConcept;
     /** Number of linear sequences of amino acids linked through peptide bonds. The number of subunits constituting the SubstanceProtein shall be described. It is possible that the number of subunits can be variable */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SubstanceReferenceInformation.d.ts b/vendor/r4/types/hl7-fhir-r4-core/SubstanceReferenceInformation.d.ts
index 6777b3b..10cfcc1 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SubstanceReferenceInformation.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/SubstanceReferenceInformation.d.ts
@@ -10,6 +10,7 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Todo. */
 export interface SubstanceReferenceInformation extends DomainResource {
+    resourceType: 'SubstanceReferenceInformation';
     /** Todo */
     comment?: string;
     _comment?: Element;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SubstanceSourceMaterial.d.ts b/vendor/r4/types/hl7-fhir-r4-core/SubstanceSourceMaterial.d.ts
index 9ded043..0c8c8ae 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SubstanceSourceMaterial.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/SubstanceSourceMaterial.d.ts
@@ -7,6 +7,7 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Source material shall capture information on the taxonomic and anatomical origins as well as the fraction of a material that can result in or can be modified to form a substance. This set of data elements shall be used to define polymer substances isolated from biological matrices. Taxonomic and anatomical origins shall be described using a controlled vocabulary as required. This information is captured for naturally derived polymers ( . starch) and structurally diverse substances. For Organisms belonging to the Kingdom Plantae the Substance level defines the fresh material of a single species or infraspecies, the Herbal Drug and the Herbal preparation. For Herbal preparations, the fraction information will be captured at the Substance information level and additional information for herbal extracts will be captured at the Specified Substance Group 1 information level. See for further explanation the Substance Class: Structurally Diverse and the herbal annex. */
 export interface SubstanceSourceMaterial extends DomainResource {
+    resourceType: 'SubstanceSourceMaterial';
     /** The parent substance of the Herbal Drug, or Herbal preparation */
     parentSubstanceName?: Array<string>;
     /** This subclause describes the organism which the substance is derived from. For vaccines, the parent organism shall be specified based on these subclause elements. As an example, full taxonomy will be described for the Substance Name: ., Leaf */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SubstanceSpecification.d.ts b/vendor/r4/types/hl7-fhir-r4-core/SubstanceSpecification.d.ts
index a9064c3..0cb6c0a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SubstanceSpecification.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/SubstanceSpecification.d.ts
@@ -13,13 +13,14 @@ import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** The detailed description of a substance, typically at a level beyond what is used for prescribing. */
 export interface SubstanceSpecification extends DomainResource {
+    resourceType: 'SubstanceSpecification';
     /** Textual description of the substance */
     description?: string;
     /** General specifications for this substance, including how it is related to other substances */
     property?: Array<SubstanceSpecificationProperty>;
     name?: Array<SubstanceSpecificationName>;
     /** General information detailing this substance */
-    referenceInformation?: Reference<"SubstanceReferenceInformation">;
+    referenceInformation?: Reference<'SubstanceReferenceInformation'>;
     /** A link between this substance and another, with details of the relationship */
     relationship?: Array<SubstanceSpecificationRelationship>;
     /** High level categorization, e.g. polymer or nucleic acid */
@@ -30,7 +31,7 @@ export interface SubstanceSpecification extends DomainResource {
     source?: Array<Reference>;
     _description?: Element;
     /** Data items specific to nucleic acids */
-    nucleicAcid?: Reference<"SubstanceNucleicAcid">;
+    nucleicAcid?: Reference<'SubstanceNucleicAcid'>;
     /** Structural information */
     structure?: SubstanceSpecificationStructure;
     /** Status of substance within the catalogue e.g. approved */
@@ -44,13 +45,13 @@ export interface SubstanceSpecification extends DomainResource {
     /** The molecular weight or weight range (for proteins, polymers or nucleic acids) */
     molecularWeight?: Array<SubstanceSpecificationStructureIsotopeMolecularWeight>;
     /** Data items specific to polymers */
-    polymer?: Reference<"SubstancePolymer">;
+    polymer?: Reference<'SubstancePolymer'>;
     /** Data items specific to proteins */
-    protein?: Reference<"SubstanceProtein">;
+    protein?: Reference<'SubstanceProtein'>;
     /** If the substance applies to only human or veterinary use */
     domain?: CodeableConcept;
     /** Material or taxonomic/anatomical source for the substance */
-    sourceMaterial?: Reference<"SubstanceSourceMaterial">;
+    sourceMaterial?: Reference<'SubstanceSourceMaterial'>;
     _comment?: Element;
 }
 /** Structural information */
@@ -151,7 +152,7 @@ export interface SubstanceSpecificationProperty extends BackboneElement {
     category?: CodeableConcept;
     _amountString?: Element;
     definingSubstanceCodeableConcept?: CodeableConcept;
-    definingSubstanceReference?: Reference<"SubstanceSpecification" | "Substance">;
+    definingSubstanceReference?: Reference<'SubstanceSpecification' | 'Substance'>;
     amountQuantity?: Quantity;
     amountString?: string;
     /** Property type e.g. viscosity, pH, isoelectric point */
@@ -182,7 +183,7 @@ export interface SubstanceSpecificationRelationship extends BackboneElement {
     relationship?: CodeableConcept;
     /** Supporting literature */
     source?: Array<Reference>;
-    substanceReference?: Reference<"SubstanceSpecification">;
+    substanceReference?: Reference<'SubstanceSpecification'>;
     amountRatio?: Ratio;
     amountQuantity?: Quantity;
     amountString?: string;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SupplyDelivery.d.ts b/vendor/r4/types/hl7-fhir-r4-core/SupplyDelivery.d.ts
index 459de3a..33eb951 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SupplyDelivery.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/SupplyDelivery.d.ts
@@ -8,24 +8,24 @@ import { Timing } from "./Timing";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** Record of delivery of what is supplied. */
 export interface SupplyDelivery extends DomainResource {
+    resourceType: 'SupplyDelivery';
     /** Patient for whom the item is supplied */
-    patient?: Reference<"Patient">;
+    patient?: Reference<'Patient'>;
     /** Dispenser */
-    supplier?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    supplier?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** The item that is delivered or supplied */
     suppliedItem?: SupplyDeliverySuppliedItem;
     _status?: Element;
     /** Category of dispense event */
-    type?: CodeableConcept;
+    type?: `${SupplyDeliveryType}`;
     occurrenceTiming?: Timing;
     occurrencePeriod?: Period;
     /** in-progress | completed | abandoned | entered-in-error */
-    status?: code;
+    status?: `${SupplyDeliveryStatus}`;
     /** External identifier */
     identifier?: Array<Identifier>;
     /** Fulfills plan, proposal or order */
@@ -36,7 +36,7 @@ export interface SupplyDelivery extends DomainResource {
     /** Who collected the Supply */
     receiver?: Array<Reference>;
     /** Where the Supply was sent */
-    destination?: Reference<"Location">;
+    destination?: Reference<'Location'>;
     _occurrenceDateTime?: Element;
 }
 /** The item that is delivered or supplied */
@@ -44,5 +44,17 @@ export interface SupplyDeliverySuppliedItem extends BackboneElement {
     /** Amount dispensed */
     quantity?: SimpleQuantity;
     itemCodeableConcept?: CodeableConcept;
-    itemReference?: Reference<"Medication" | "Device" | "Substance">;
+    itemReference?: Reference<'Medication' | 'Device' | 'Substance'>;
+}
+/** Category of dispense event */
+export declare enum SupplyDeliveryType {
+    Device = "device",
+    Medication = "medication"
+}
+/** in-progress | completed | abandoned | entered-in-error */
+export declare enum SupplyDeliveryStatus {
+    Abandoned = "abandoned",
+    Completed = "completed",
+    EnteredInError = "entered-in-error",
+    InProgress = "in-progress"
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SupplyDelivery.js b/vendor/r4/types/hl7-fhir-r4-core/SupplyDelivery.js
index c8ad2e5..274c7a8 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SupplyDelivery.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/SupplyDelivery.js
@@ -1,2 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupplyDeliveryStatus = exports.SupplyDeliveryType = void 0;
+/** Category of dispense event */
+var SupplyDeliveryType;
+(function (SupplyDeliveryType) {
+    SupplyDeliveryType["Device"] = "device";
+    SupplyDeliveryType["Medication"] = "medication";
+})(SupplyDeliveryType = exports.SupplyDeliveryType || (exports.SupplyDeliveryType = {}));
+/** in-progress | completed | abandoned | entered-in-error */
+var SupplyDeliveryStatus;
+(function (SupplyDeliveryStatus) {
+    SupplyDeliveryStatus["Abandoned"] = "abandoned";
+    SupplyDeliveryStatus["Completed"] = "completed";
+    SupplyDeliveryStatus["EnteredInError"] = "entered-in-error";
+    SupplyDeliveryStatus["InProgress"] = "in-progress";
+})(SupplyDeliveryStatus = exports.SupplyDeliveryStatus || (exports.SupplyDeliveryStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SupplyRequest.d.ts b/vendor/r4/types/hl7-fhir-r4-core/SupplyRequest.d.ts
index 02da57b..eb213a0 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SupplyRequest.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/SupplyRequest.d.ts
@@ -9,19 +9,19 @@ import { Quantity } from "./Quantity";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A record of a request for a medication, substance or device used in the healthcare setting. */
 export interface SupplyRequest extends DomainResource {
+    resourceType: 'SupplyRequest';
     /** The kind of supply (central, non-stock, etc.) */
     category?: CodeableConcept;
     /** Who is intended to fulfill the request */
     supplier?: Array<Reference>;
     /** The destination of the supply */
-    deliverTo?: Reference<"Patient" | "Organization" | "Location">;
+    deliverTo?: Reference<'Patient' | 'Organization' | 'Location'>;
     _authoredOn?: Element;
-    itemReference: Reference<"Medication" | "Device" | "Substance">;
+    itemReference: Reference<'Medication' | 'Device' | 'Substance'>;
     _priority?: Element;
     _status?: Element;
     /** The reason why the supply item was requested */
@@ -30,14 +30,14 @@ export interface SupplyRequest extends DomainResource {
     authoredOn?: dateTime;
     occurrenceTiming?: Timing;
     /** The origin of the supply */
-    deliverFrom?: Reference<"Organization" | "Location">;
+    deliverFrom?: Reference<'Organization' | 'Location'>;
     /** Individual making the request */
-    requester?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    requester?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** routine | urgent | asap | stat */
-    priority?: code;
+    priority?: `${SupplyRequestPriority}`;
     occurrencePeriod?: Period;
     /** draft | active | suspended + */
-    status?: code;
+    status?: `${SupplyRequestStatus}`;
     /** Business Identifier for SupplyRequest */
     identifier?: Array<Identifier>;
     itemCodeableConcept: CodeableConcept;
@@ -50,6 +50,23 @@ export interface SupplyRequest extends DomainResource {
     reasonReference?: Array<Reference>;
     _occurrenceDateTime?: Element;
 }
+/** routine | urgent | asap | stat */
+export declare enum SupplyRequestPriority {
+    Asap = "asap",
+    Routine = "routine",
+    Stat = "stat",
+    Urgent = "urgent"
+}
+/** draft | active | suspended + */
+export declare enum SupplyRequestStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Completed = "completed",
+    Draft = "draft",
+    EnteredInError = "entered-in-error",
+    Suspended = "suspended",
+    Unknown = "unknown"
+}
 /** Ordered item details */
 export interface SupplyRequestParameter extends BackboneElement {
     /** Item detail */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/SupplyRequest.js b/vendor/r4/types/hl7-fhir-r4-core/SupplyRequest.js
index c8ad2e5..511d512 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/SupplyRequest.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/SupplyRequest.js
@@ -1,2 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupplyRequestStatus = exports.SupplyRequestPriority = void 0;
+/** routine | urgent | asap | stat */
+var SupplyRequestPriority;
+(function (SupplyRequestPriority) {
+    SupplyRequestPriority["Asap"] = "asap";
+    SupplyRequestPriority["Routine"] = "routine";
+    SupplyRequestPriority["Stat"] = "stat";
+    SupplyRequestPriority["Urgent"] = "urgent";
+})(SupplyRequestPriority = exports.SupplyRequestPriority || (exports.SupplyRequestPriority = {}));
+/** draft | active | suspended + */
+var SupplyRequestStatus;
+(function (SupplyRequestStatus) {
+    SupplyRequestStatus["Active"] = "active";
+    SupplyRequestStatus["Cancelled"] = "cancelled";
+    SupplyRequestStatus["Completed"] = "completed";
+    SupplyRequestStatus["Draft"] = "draft";
+    SupplyRequestStatus["EnteredInError"] = "entered-in-error";
+    SupplyRequestStatus["Suspended"] = "suspended";
+    SupplyRequestStatus["Unknown"] = "unknown";
+})(SupplyRequestStatus = exports.SupplyRequestStatus || (exports.SupplyRequestStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Task.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Task.d.ts
index 3f2b7be..343bfdb 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Task.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Task.d.ts
@@ -53,6 +53,7 @@ import { decimal } from "./decimal";
 import { Contributor } from "./Contributor";
 /** A task to be performed. */
 export interface Task extends DomainResource {
+    resourceType: 'Task';
     /** Constraints on fulfillment tasks */
     restriction?: TaskRestriction;
     /** Human-readable explanation of task */
@@ -71,7 +72,7 @@ export interface Task extends DomainResource {
     relevantHistory?: Array<Reference>;
     _authoredOn?: Element;
     /** Healthcare event during which this task originated */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _priority?: Element;
     _status?: Element;
     /** Why task is needed */
@@ -91,13 +92,13 @@ export interface Task extends DomainResource {
     /** Beneficiary of the Task */
     for?: Reference;
     /** Who is asking for task to be done */
-    requester?: Reference<"Patient" | "PractitionerRole" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    requester?: Reference<'Patient' | 'PractitionerRole' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** Task Last Modified Date */
     lastModified?: dateTime;
     /** routine | urgent | asap | stat */
-    priority?: code;
+    priority?: `${TaskPriority}`;
     /** draft | requested | received | accepted | + */
-    status: code;
+    status: `${TaskStatus}`;
     /** Requisition or grouper id */
     groupIdentifier?: Identifier;
     /** Task Type */
@@ -105,7 +106,7 @@ export interface Task extends DomainResource {
     /** Task Instance Identifier */
     identifier?: Array<Identifier>;
     /** unknown | proposal | plan | order | original-order | reflex-order | filler-order | instance-order | option */
-    intent: code;
+    intent: `${TaskIntent}`;
     /** What task is acting on */
     focus?: Reference;
     /** Information used to perform task */
@@ -116,10 +117,10 @@ export interface Task extends DomainResource {
     partOf?: Array<Reference>;
     _lastModified?: Element;
     /** Where task occurs */
-    location?: Reference<"Location">;
+    location?: Reference<'Location'>;
     _instantiatesCanonical?: Element;
     /** Responsible individual */
-    owner?: Reference<"CareTeam" | "Patient" | "PractitionerRole" | "HealthcareService" | "Organization" | "Device" | "Practitioner" | "RelatedPerson">;
+    owner?: Reference<'CareTeam' | 'Patient' | 'PractitionerRole' | 'HealthcareService' | 'Organization' | 'Device' | 'Practitioner' | 'RelatedPerson'>;
     /** Why task is needed */
     reasonReference?: Reference;
     _instantiatesUri?: Element;
@@ -208,6 +209,40 @@ export interface TaskOutput extends BackboneElement {
     valueUrl: url;
     _valueInteger: Element;
 }
+/** routine | urgent | asap | stat */
+export declare enum TaskPriority {
+    Asap = "asap",
+    Routine = "routine",
+    Stat = "stat",
+    Urgent = "urgent"
+}
+/** draft | requested | received | accepted | + */
+export declare enum TaskStatus {
+    Draft = "draft",
+    Failed = "failed",
+    Cancelled = "cancelled",
+    Rejected = "rejected",
+    Ready = "ready",
+    InProgress = "in-progress",
+    EnteredInError = "entered-in-error",
+    Completed = "completed",
+    Received = "received",
+    Requested = "requested",
+    Accepted = "accepted",
+    OnHold = "on-hold"
+}
+/** unknown | proposal | plan | order | original-order | reflex-order | filler-order | instance-order | option */
+export declare enum TaskIntent {
+    Order = "order",
+    FillerOrder = "filler-order",
+    Option = "option",
+    Unknown = "unknown",
+    Proposal = "proposal",
+    ReflexOrder = "reflex-order",
+    Plan = "plan",
+    InstanceOrder = "instance-order",
+    OriginalOrder = "original-order"
+}
 /** Information used to perform task */
 export interface TaskInput extends BackboneElement {
     valueBase64Binary: base64Binary;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Task.js b/vendor/r4/types/hl7-fhir-r4-core/Task.js
index c8ad2e5..fda3d2a 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Task.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Task.js
@@ -1,2 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskIntent = exports.TaskStatus = exports.TaskPriority = void 0;
+/** routine | urgent | asap | stat */
+var TaskPriority;
+(function (TaskPriority) {
+    TaskPriority["Asap"] = "asap";
+    TaskPriority["Routine"] = "routine";
+    TaskPriority["Stat"] = "stat";
+    TaskPriority["Urgent"] = "urgent";
+})(TaskPriority = exports.TaskPriority || (exports.TaskPriority = {}));
+/** draft | requested | received | accepted | + */
+var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["Draft"] = "draft";
+    TaskStatus["Failed"] = "failed";
+    TaskStatus["Cancelled"] = "cancelled";
+    TaskStatus["Rejected"] = "rejected";
+    TaskStatus["Ready"] = "ready";
+    TaskStatus["InProgress"] = "in-progress";
+    TaskStatus["EnteredInError"] = "entered-in-error";
+    TaskStatus["Completed"] = "completed";
+    TaskStatus["Received"] = "received";
+    TaskStatus["Requested"] = "requested";
+    TaskStatus["Accepted"] = "accepted";
+    TaskStatus["OnHold"] = "on-hold";
+})(TaskStatus = exports.TaskStatus || (exports.TaskStatus = {}));
+/** unknown | proposal | plan | order | original-order | reflex-order | filler-order | instance-order | option */
+var TaskIntent;
+(function (TaskIntent) {
+    TaskIntent["Order"] = "order";
+    TaskIntent["FillerOrder"] = "filler-order";
+    TaskIntent["Option"] = "option";
+    TaskIntent["Unknown"] = "unknown";
+    TaskIntent["Proposal"] = "proposal";
+    TaskIntent["ReflexOrder"] = "reflex-order";
+    TaskIntent["Plan"] = "plan";
+    TaskIntent["InstanceOrder"] = "instance-order";
+    TaskIntent["OriginalOrder"] = "original-order";
+})(TaskIntent = exports.TaskIntent || (exports.TaskIntent = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/TerminologyCapabilities.d.ts b/vendor/r4/types/hl7-fhir-r4-core/TerminologyCapabilities.d.ts
index 46a9e0c..098fe4f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/TerminologyCapabilities.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/TerminologyCapabilities.d.ts
@@ -14,6 +14,7 @@ import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation. */
 export interface TerminologyCapabilities extends DomainResource {
+    resourceType: 'TerminologyCapabilities';
     /** Natural language description of the terminology capabilities */
     description?: markdown;
     _kind?: Element;
@@ -46,11 +47,11 @@ export interface TerminologyCapabilities extends DomainResource {
     _description?: Element;
     _purpose?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${TerminologyCapabilitiesStatus}`;
     /** Information about the [ValueSet/$validate-code](valueset-operation-validate-code.html) operation */
     validateCode?: TerminologyCapabilitiesValidateCode;
     /** instance | capability | requirements */
-    kind: code;
+    kind: `${TerminologyCapabilitiesKind}`;
     _name?: Element;
     /** Information about the [ConceptMap/$translate](conceptmap-operation-translate.html) operation */
     translation?: TerminologyCapabilitiesTranslation;
@@ -71,7 +72,7 @@ export interface TerminologyCapabilities extends DomainResource {
     implementation?: TerminologyCapabilitiesImplementation;
     _url?: Element;
     /** explicit | all */
-    codeSearch?: code;
+    codeSearch?: `${TerminologyCapabilitiesCodeSearch}`;
     /** Whether lockedDate is supported */
     lockedDate?: boolean;
     /** Information about the [ConceptMap/$closure](conceptmap-operation-closure.html) operation */
@@ -83,6 +84,11 @@ export interface TerminologyCapabilitiesTranslation extends BackboneElement {
     needsMap: boolean;
     _needsMap?: Element;
 }
+/** explicit | all */
+export declare enum TerminologyCapabilitiesCodeSearch {
+    All = "all",
+    Explicit = "explicit"
+}
 /** Information about the [ValueSet/$expand](valueset-operation-expand.html) operation */
 export interface TerminologyCapabilitiesExpansion extends BackboneElement {
     /** Whether the server can return nested value sets */
@@ -115,6 +121,12 @@ export interface TerminologyCapabilitiesSoftware extends BackboneElement {
     version?: string;
     _version?: Element;
 }
+/** instance | capability | requirements */
+export declare enum TerminologyCapabilitiesKind {
+    Capability = "capability",
+    Instance = "instance",
+    Requirements = "requirements"
+}
 /** A code system supported by the server */
 export interface TerminologyCapabilitiesCodeSystem extends BackboneElement {
     /** URI for the Code System */
@@ -135,6 +147,13 @@ export interface TerminologyCapabilitiesFilter extends BackboneElement {
     op: Array<code>;
     _op?: Array<Element>;
 }
+/** draft | active | retired | unknown */
+export declare enum TerminologyCapabilitiesStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
 /** Supported expansion parameter */
 export interface TerminologyCapabilitiesParameter extends BackboneElement {
     /** Expansion Parameter name */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/TerminologyCapabilities.js b/vendor/r4/types/hl7-fhir-r4-core/TerminologyCapabilities.js
index c8ad2e5..ffea4fa 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/TerminologyCapabilities.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/TerminologyCapabilities.js
@@ -1,2 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminologyCapabilitiesStatus = exports.TerminologyCapabilitiesKind = exports.TerminologyCapabilitiesCodeSearch = void 0;
+/** explicit | all */
+var TerminologyCapabilitiesCodeSearch;
+(function (TerminologyCapabilitiesCodeSearch) {
+    TerminologyCapabilitiesCodeSearch["All"] = "all";
+    TerminologyCapabilitiesCodeSearch["Explicit"] = "explicit";
+})(TerminologyCapabilitiesCodeSearch = exports.TerminologyCapabilitiesCodeSearch || (exports.TerminologyCapabilitiesCodeSearch = {}));
+/** instance | capability | requirements */
+var TerminologyCapabilitiesKind;
+(function (TerminologyCapabilitiesKind) {
+    TerminologyCapabilitiesKind["Capability"] = "capability";
+    TerminologyCapabilitiesKind["Instance"] = "instance";
+    TerminologyCapabilitiesKind["Requirements"] = "requirements";
+})(TerminologyCapabilitiesKind = exports.TerminologyCapabilitiesKind || (exports.TerminologyCapabilitiesKind = {}));
+/** draft | active | retired | unknown */
+var TerminologyCapabilitiesStatus;
+(function (TerminologyCapabilitiesStatus) {
+    TerminologyCapabilitiesStatus["Active"] = "active";
+    TerminologyCapabilitiesStatus["Draft"] = "draft";
+    TerminologyCapabilitiesStatus["Retired"] = "retired";
+    TerminologyCapabilitiesStatus["Unknown"] = "unknown";
+})(TerminologyCapabilitiesStatus = exports.TerminologyCapabilitiesStatus || (exports.TerminologyCapabilitiesStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/TestReport.d.ts b/vendor/r4/types/hl7-fhir-r4-core/TestReport.d.ts
index bc8aa53..0361c3c 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/TestReport.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/TestReport.d.ts
@@ -6,12 +6,12 @@ import { DomainResource } from "./DomainResource";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** A summary of information based on the results of executing a TestScript. */
 export interface TestReport extends DomainResource {
+    resourceType: 'TestReport';
     _issued?: Element;
     /** Name of the tester producing this report (Organization or individual) */
     tester?: string;
@@ -20,16 +20,16 @@ export interface TestReport extends DomainResource {
     _status?: Element;
     _score?: Element;
     /** Reference to the  version-specific TestScript that was executed to produce this TestReport */
-    testScript: Reference<"TestScript">;
+    testScript: Reference<'TestScript'>;
     /** A participant in the test execution, either the execution engine, a client, or a server */
     participant?: Array<TestReportParticipant>;
     _result?: Element;
     /** The results of the series of required setup operations before the tests were executed */
     setup?: TestReportSetup;
     /** completed | in-progress | waiting | stopped | entered-in-error */
-    status: code;
+    status: `${TestReportStatus}`;
     /** pass | fail | pending */
-    result: code;
+    result: `${TestReportResult}`;
     /** The final score (percentage of tests passed) resulting from the execution of the TestScript */
     score?: decimal;
     _name?: Element;
@@ -43,33 +43,6 @@ export interface TestReport extends DomainResource {
     /** A test executed from the test script */
     test?: Array<TestReportTest>;
 }
-/** A participant in the test execution, either the execution engine, a client, or a server */
-export interface TestReportParticipant extends BackboneElement {
-    /** test-engine | client | server */
-    type: code;
-    _type?: Element;
-    /** The uri of the participant. An absolute URL is preferred */
-    uri: uri;
-    _uri?: Element;
-    /** The display name of the participant */
-    display?: string;
-    _display?: Element;
-}
-/** A setup operation or assert that was executed */
-export interface TestReportAction extends BackboneElement {
-    operation?: TestReportSetupActionOperation;
-    assert?: TestReportSetupActionAssert;
-}
-/** The results of the series of required setup operations before the tests were executed */
-export interface TestReportSetup extends BackboneElement {
-    /** A setup operation or assert that was executed */
-    action: Array<TestReportAction>;
-}
-/** The results of running the series of required clean up steps */
-export interface TestReportTeardown extends BackboneElement {
-    /** One or more teardown operations performed */
-    action: Array<TestReportAction>;
-}
 /** A test executed from the test script */
 export interface TestReportTest extends BackboneElement {
     /** Tracking/logging name of this test */
@@ -81,10 +54,37 @@ export interface TestReportTest extends BackboneElement {
     /** A test operation or assert that was performed */
     action: Array<TestReportAction>;
 }
+/** pass | skip | fail | warning | error */
+export declare enum TestReportSetupActionAssertResult {
+    Error = "error",
+    Fail = "fail",
+    Pass = "pass",
+    Skip = "skip",
+    Warning = "warning"
+}
+/** The results of the series of required setup operations before the tests were executed */
+export interface TestReportSetup extends BackboneElement {
+    /** A setup operation or assert that was executed */
+    action: Array<TestReportAction>;
+}
+/** pass | skip | fail | warning | error */
+export declare enum TestReportSetupActionOperationResult {
+    Error = "error",
+    Fail = "fail",
+    Pass = "pass",
+    Skip = "skip",
+    Warning = "warning"
+}
+/** test-engine | client | server */
+export declare enum TestReportType {
+    Client = "client",
+    Server = "server",
+    TestEngine = "test-engine"
+}
 /** The assertion to perform */
 export interface TestReportSetupActionAssert extends BackboneElement {
     /** pass | skip | fail | warning | error */
-    result: code;
+    result: `${TestReportSetupActionAssertResult}`;
     _result?: Element;
     /** A message associated with the result */
     message?: markdown;
@@ -93,10 +93,38 @@ export interface TestReportSetupActionAssert extends BackboneElement {
     detail?: string;
     _detail?: Element;
 }
+/** A participant in the test execution, either the execution engine, a client, or a server */
+export interface TestReportParticipant extends BackboneElement {
+    /** test-engine | client | server */
+    type: `${TestReportType}`;
+    _type?: Element;
+    /** The uri of the participant. An absolute URL is preferred */
+    uri: uri;
+    _uri?: Element;
+    /** The display name of the participant */
+    display?: string;
+    _display?: Element;
+}
+/** A setup operation or assert that was executed */
+export interface TestReportAction extends BackboneElement {
+    operation?: TestReportSetupActionOperation;
+    assert?: TestReportSetupActionAssert;
+}
+/** The results of running the series of required clean up steps */
+export interface TestReportTeardown extends BackboneElement {
+    /** One or more teardown operations performed */
+    action: Array<TestReportAction>;
+}
+/** pass | fail | pending */
+export declare enum TestReportResult {
+    Fail = "fail",
+    Pass = "pass",
+    Pending = "pending"
+}
 /** The operation to perform */
 export interface TestReportSetupActionOperation extends BackboneElement {
     /** pass | skip | fail | warning | error */
-    result: code;
+    result: `${TestReportSetupActionOperationResult}`;
     _result?: Element;
     /** A message associated with the result */
     message?: markdown;
@@ -105,3 +133,11 @@ export interface TestReportSetupActionOperation extends BackboneElement {
     detail?: uri;
     _detail?: Element;
 }
+/** completed | in-progress | waiting | stopped | entered-in-error */
+export declare enum TestReportStatus {
+    Completed = "completed",
+    EnteredInError = "entered-in-error",
+    InProgress = "in-progress",
+    Stopped = "stopped",
+    Waiting = "waiting"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/TestReport.js b/vendor/r4/types/hl7-fhir-r4-core/TestReport.js
index c8ad2e5..c306c7f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/TestReport.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/TestReport.js
@@ -1,2 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestReportStatus = exports.TestReportResult = exports.TestReportType = exports.TestReportSetupActionOperationResult = exports.TestReportSetupActionAssertResult = void 0;
+/** pass | skip | fail | warning | error */
+var TestReportSetupActionAssertResult;
+(function (TestReportSetupActionAssertResult) {
+    TestReportSetupActionAssertResult["Error"] = "error";
+    TestReportSetupActionAssertResult["Fail"] = "fail";
+    TestReportSetupActionAssertResult["Pass"] = "pass";
+    TestReportSetupActionAssertResult["Skip"] = "skip";
+    TestReportSetupActionAssertResult["Warning"] = "warning";
+})(TestReportSetupActionAssertResult = exports.TestReportSetupActionAssertResult || (exports.TestReportSetupActionAssertResult = {}));
+/** pass | skip | fail | warning | error */
+var TestReportSetupActionOperationResult;
+(function (TestReportSetupActionOperationResult) {
+    TestReportSetupActionOperationResult["Error"] = "error";
+    TestReportSetupActionOperationResult["Fail"] = "fail";
+    TestReportSetupActionOperationResult["Pass"] = "pass";
+    TestReportSetupActionOperationResult["Skip"] = "skip";
+    TestReportSetupActionOperationResult["Warning"] = "warning";
+})(TestReportSetupActionOperationResult = exports.TestReportSetupActionOperationResult || (exports.TestReportSetupActionOperationResult = {}));
+/** test-engine | client | server */
+var TestReportType;
+(function (TestReportType) {
+    TestReportType["Client"] = "client";
+    TestReportType["Server"] = "server";
+    TestReportType["TestEngine"] = "test-engine";
+})(TestReportType = exports.TestReportType || (exports.TestReportType = {}));
+/** pass | fail | pending */
+var TestReportResult;
+(function (TestReportResult) {
+    TestReportResult["Fail"] = "fail";
+    TestReportResult["Pass"] = "pass";
+    TestReportResult["Pending"] = "pending";
+})(TestReportResult = exports.TestReportResult || (exports.TestReportResult = {}));
+/** completed | in-progress | waiting | stopped | entered-in-error */
+var TestReportStatus;
+(function (TestReportStatus) {
+    TestReportStatus["Completed"] = "completed";
+    TestReportStatus["EnteredInError"] = "entered-in-error";
+    TestReportStatus["InProgress"] = "in-progress";
+    TestReportStatus["Stopped"] = "stopped";
+    TestReportStatus["Waiting"] = "waiting";
+})(TestReportStatus = exports.TestReportStatus || (exports.TestReportStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/TestScript.d.ts b/vendor/r4/types/hl7-fhir-r4-core/TestScript.d.ts
index 11c8b58..461e1bf 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/TestScript.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/TestScript.d.ts
@@ -13,11 +13,11 @@ import { DomainResource } from "./DomainResource";
 import { markdown } from "./markdown";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 /** A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification. */
 export interface TestScript extends DomainResource {
+    resourceType: 'TestScript';
     /** Natural language description of the test script */
     description?: markdown;
     /** Date last changed */
@@ -49,7 +49,7 @@ export interface TestScript extends DomainResource {
     setup?: TestScriptSetup;
     _purpose?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${TestScriptStatus}`;
     _name?: Element;
     /** Canonical identifier for this test script, represented as a URI (globally unique) */
     url: uri;
@@ -112,6 +112,13 @@ export interface TestScriptVariable extends BackboneElement {
     /** Default, hard-coded, or user-defined value for this variable */
     defaultValue?: string;
 }
+/** Mime type of the request payload contents, with charset etc. */
+export declare enum TestScriptSetupActionOperationContentType {
+    "Application/hl7Cda+xml" = "application/hl7-cda+xml",
+    "Application/sparqlResults+xml" = "application/sparql-results+xml",
+    "Application/sql" = "application/sql",
+    "Application/xquery" = "application/xquery"
+}
 /** An abstract server representing a client or sender in a message exchange */
 export interface TestScriptOrigin extends BackboneElement {
     /** The index of the abstract origin server starting at 1 */
@@ -130,7 +137,7 @@ export interface TestScriptSetupActionOperation extends BackboneElement {
     _encodeRequestUrl?: Element;
     _targetId?: Element;
     /** delete | get | options | patch | post | put | head */
-    method?: code;
+    method?: `${TestScriptSetupActionOperationMethod}`;
     /** Id of fixture used for extracting the [id],  [type], and [vid] for GET requests */
     targetId?: id;
     _contentType?: Element;
@@ -152,13 +159,13 @@ export interface TestScriptSetupActionOperation extends BackboneElement {
     /** Tracking/logging operation label */
     label?: string;
     /** Resource type */
-    resource?: code;
+    resource?: `${TestScriptSetupActionOperationResource}`;
     /** Request URL */
     url?: string;
     /** Server initiating the request */
     origin?: integer;
     /** Mime type of the request payload contents, with charset etc. */
-    contentType?: code;
+    contentType?: `${TestScriptSetupActionOperationContentType}`;
     _responseId?: Element;
     /** Fixture Id of body for PUT and POST requests */
     sourceId?: id;
@@ -170,12 +177,248 @@ export interface TestScriptSetupActionOperation extends BackboneElement {
     destination?: integer;
     _url?: Element;
     /** Mime type to accept in the payload of the response, with charset etc. */
-    accept?: code;
+    accept?: `${TestScriptSetupActionOperationAccept}`;
+}
+/** Resource type */
+export declare enum TestScriptSetupActionOperationResource {
+    ImmunizationEvaluation = "ImmunizationEvaluation",
+    Appointment = "Appointment",
+    StructureMap = "StructureMap",
+    Address = "Address",
+    CareTeam = "CareTeam",
+    UsageContext = "UsageContext",
+    Linkage = "Linkage",
+    Annotation = "Annotation",
+    Age = "Age",
+    Attachment = "Attachment",
+    Communication = "Communication",
+    MedicationDispense = "MedicationDispense",
+    ImagingStudy = "ImagingStudy",
+    ChargeItem = "ChargeItem",
+    Period = "Period",
+    AdverseEvent = "AdverseEvent",
+    ContactDetail = "ContactDetail",
+    DataRequirement = "DataRequirement",
+    Media = "Media",
+    CodeableConcept = "CodeableConcept",
+    Uri = "uri",
+    SubstancePolymer = "SubstancePolymer",
+    QuestionnaireResponse = "QuestionnaireResponse",
+    Coverage = "Coverage",
+    Procedure = "Procedure",
+    AuditEvent = "AuditEvent",
+    PaymentReconciliation = "PaymentReconciliation",
+    MedicinalProductManufactured = "MedicinalProductManufactured",
+    CompartmentDefinition = "CompartmentDefinition",
+    Organization = "Organization",
+    ExplanationOfBenefit = "ExplanationOfBenefit",
+    Composition = "Composition",
+    SimpleQuantity = "SimpleQuantity",
+    CoverageEligibilityResponse = "CoverageEligibilityResponse",
+    DocumentReference = "DocumentReference",
+    EventDefinition = "EventDefinition",
+    SubstanceProtein = "SubstanceProtein",
+    TerminologyCapabilities = "TerminologyCapabilities",
+    Encounter = "Encounter",
+    ImplementationGuide = "ImplementationGuide",
+    EvidenceVariable = "EvidenceVariable",
+    ObservationDefinition = "ObservationDefinition",
+    DiagnosticReport = "DiagnosticReport",
+    ExampleScenario = "ExampleScenario",
+    ResearchDefinition = "ResearchDefinition",
+    Parameters = "Parameters",
+    Instant = "instant",
+    SearchParameter = "SearchParameter",
+    MedicinalProductInteraction = "MedicinalProductInteraction",
+    CodeSystem = "CodeSystem",
+    MessageDefinition = "MessageDefinition",
+    NutritionOrder = "NutritionOrder",
+    VerificationResult = "VerificationResult",
+    MedicationAdministration = "MedicationAdministration",
+    CatalogEntry = "CatalogEntry",
+    Flag = "Flag",
+    DeviceUseStatement = "DeviceUseStatement",
+    TriggerDefinition = "TriggerDefinition",
+    Contract = "Contract",
+    Invoice = "Invoice",
+    MarketingStatus = "MarketingStatus",
+    Count = "Count",
+    PaymentNotice = "PaymentNotice",
+    Location = "Location",
+    Claim = "Claim",
+    Specimen = "Specimen",
+    MedicationStatement = "MedicationStatement",
+    EnrollmentResponse = "EnrollmentResponse",
+    Uuid = "uuid",
+    Evidence = "Evidence",
+    Bundle = "Bundle",
+    ResearchElementDefinition = "ResearchElementDefinition",
+    Expression = "Expression",
+    Coding = "Coding",
+    BodyStructure = "BodyStructure",
+    MedicinalProduct = "MedicinalProduct",
+    Canonical = "canonical",
+    ResearchStudy = "ResearchStudy",
+    Dosage = "Dosage",
+    AppointmentResponse = "AppointmentResponse",
+    MedicinalProductIndication = "MedicinalProductIndication",
+    Measure = "Measure",
+    Person = "Person",
+    InsurancePlan = "InsurancePlan",
+    Date = "date",
+    Patient = "Patient",
+    EffectEvidenceSynthesis = "EffectEvidenceSynthesis",
+    ResearchSubject = "ResearchSubject",
+    Medication = "Medication",
+    Range = "Range",
+    ConceptMap = "ConceptMap",
+    CoverageEligibilityRequest = "CoverageEligibilityRequest",
+    Population = "Population",
+    SubstanceSourceMaterial = "SubstanceSourceMaterial",
+    VisionPrescription = "VisionPrescription",
+    MolecularSequence = "MolecularSequence",
+    MedicinalProductUndesirableEffect = "MedicinalProductUndesirableEffect",
+    OperationOutcome = "OperationOutcome",
+    MessageHeader = "MessageHeader",
+    ContactPoint = "ContactPoint",
+    Signature = "Signature",
+    Decimal = "decimal",
+    AllergyIntolerance = "AllergyIntolerance",
+    SubstanceReferenceInformation = "SubstanceReferenceInformation",
+    SupplyDelivery = "SupplyDelivery",
+    EpisodeOfCare = "EpisodeOfCare",
+    PractitionerRole = "PractitionerRole",
+    Library = "Library",
+    Practitioner = "Practitioner",
+    Markdown = "markdown",
+    MedicationRequest = "MedicationRequest",
+    ImmunizationRecommendation = "ImmunizationRecommendation",
+    RelatedArtifact = "RelatedArtifact",
+    Timing = "Timing",
+    Immunization = "Immunization",
+    GraphDefinition = "GraphDefinition",
+    Account = "Account",
+    Url = "url",
+    MedicinalProductIngredient = "MedicinalProductIngredient",
+    ProdCharacteristic = "ProdCharacteristic",
+    Meta = "Meta",
+    Quantity = "Quantity",
+    MeasureReport = "MeasureReport",
+    Distance = "Distance",
+    HumanName = "HumanName",
+    DeviceMetric = "DeviceMetric",
+    Duration = "Duration",
+    SubstanceAmount = "SubstanceAmount",
+    Goal = "Goal",
+    MedicationKnowledge = "MedicationKnowledge",
+    Integer = "integer",
+    String = "string",
+    ClaimResponse = "ClaimResponse",
+    DeviceDefinition = "DeviceDefinition",
+    Slot = "Slot",
+    ValueSet = "ValueSet",
+    MedicinalProductAuthorization = "MedicinalProductAuthorization",
+    StructureDefinition = "StructureDefinition",
+    Base64Binary = "base64Binary",
+    MedicinalProductContraindication = "MedicinalProductContraindication",
+    ElementDefinition = "ElementDefinition",
+    DeviceRequest = "DeviceRequest",
+    List = "List",
+    Questionnaire = "Questionnaire",
+    DomainResource = "DomainResource",
+    Endpoint = "Endpoint",
+    NamingSystem = "NamingSystem",
+    MedicinalProductPackaged = "MedicinalProductPackaged",
+    Basic = "Basic",
+    Money = "Money",
+    Binary = "Binary",
+    PlanDefinition = "PlanDefinition",
+    Subscription = "Subscription",
+    SampledData = "SampledData",
+    ProductShelfLife = "ProductShelfLife",
+    RelatedPerson = "RelatedPerson",
+    SubstanceSpecification = "SubstanceSpecification",
+    Ratio = "Ratio",
+    SubstanceNucleicAcid = "SubstanceNucleicAcid",
+    GuidanceResponse = "GuidanceResponse",
+    ClinicalImpression = "ClinicalImpression",
+    OrganizationAffiliation = "OrganizationAffiliation",
+    Resource = "Resource",
+    UnsignedInt = "unsignedInt",
+    Condition = "Condition",
+    Extension = "Extension",
+    CapabilityStatement = "CapabilityStatement",
+    HealthcareService = "HealthcareService",
+    SpecimenDefinition = "SpecimenDefinition",
+    ParameterDefinition = "ParameterDefinition",
+    RiskAssessment = "RiskAssessment",
+    Xhtml = "xhtml",
+    OperationDefinition = "OperationDefinition",
+    ActivityDefinition = "ActivityDefinition",
+    Schedule = "Schedule",
+    BiologicallyDerivedProduct = "BiologicallyDerivedProduct",
+    PositiveInt = "positiveInt",
+    Code = "code",
+    Group = "Group",
+    MedicinalProductPharmaceutical = "MedicinalProductPharmaceutical",
+    FamilyMemberHistory = "FamilyMemberHistory",
+    ServiceRequest = "ServiceRequest",
+    DetectedIssue = "DetectedIssue",
+    Device = "Device",
+    Oid = "oid",
+    RequestGroup = "RequestGroup",
+    TestScript = "TestScript",
+    RiskEvidenceSynthesis = "RiskEvidenceSynthesis",
+    SupplyRequest = "SupplyRequest",
+    Element = "Element",
+    Reference = "Reference",
+    Task = "Task",
+    Identifier = "Identifier",
+    CommunicationRequest = "CommunicationRequest",
+    EnrollmentRequest = "EnrollmentRequest",
+    ChargeItemDefinition = "ChargeItemDefinition",
+    Substance = "Substance",
+    Id = "id",
+    Provenance = "Provenance",
+    Time = "time",
+    Consent = "Consent",
+    BackboneElement = "BackboneElement",
+    CarePlan = "CarePlan",
+    Narrative = "Narrative",
+    MoneyQuantity = "MoneyQuantity",
+    TestReport = "TestReport",
+    Observation = "Observation",
+    DateTime = "dateTime",
+    Boolean = "boolean",
+    DocumentManifest = "DocumentManifest",
+    Contributor = "Contributor"
+}
+/** okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable */
+export declare enum TestScriptSetupActionAssertResponse {
+    Unprocessable = "unprocessable",
+    Created = "created",
+    NotFound = "notFound",
+    MethodNotAllowed = "methodNotAllowed",
+    Conflict = "conflict",
+    Gone = "gone",
+    Bad = "bad",
+    PreconditionFailed = "preconditionFailed",
+    Okay = "okay",
+    NoContent = "noContent",
+    Forbidden = "forbidden",
+    NotModified = "notModified"
+}
+/** Mime type to compare against the 'Content-Type' header */
+export declare enum TestScriptSetupActionAssertContentType {
+    "Application/hl7Cda+xml" = "application/hl7-cda+xml",
+    "Application/sparqlResults+xml" = "application/sparql-results+xml",
+    "Application/sql" = "application/sql",
+    "Application/xquery" = "application/xquery"
 }
 /** The assertion to perform */
 export interface TestScriptSetupActionAssert extends BackboneElement {
     /** okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable */
-    response?: code;
+    response?: `${TestScriptSetupActionAssertResponse}`;
     /** Tracking/reporting assertion description */
     description?: string;
     /** XPath or JSONPath expression */
@@ -212,15 +455,15 @@ export interface TestScriptSetupActionAssert extends BackboneElement {
     /** Tracking/logging assertion label */
     label?: string;
     /** Resource type */
-    resource?: code;
+    resource?: `${TestScriptSetupActionAssertResource}`;
     /** HTTP response code to test */
     responseCode?: string;
     /** Fixture Id of minimum content resource */
     minimumId?: string;
     /** equals | notEquals | in | notIn | greaterThan | lessThan | empty | notEmpty | contains | notContains | eval */
-    operator?: code;
+    operator?: `${TestScriptSetupActionAssertOperator}`;
     /** Mime type to compare against the 'Content-Type' header */
-    contentType?: code;
+    contentType?: `${TestScriptSetupActionAssertContentType}`;
     /** XPath or JSONPath expression to evaluate against the source fixture */
     compareToSourcePath?: string;
     /** Profile Id of validation profile reference */
@@ -231,13 +474,13 @@ export interface TestScriptSetupActionAssert extends BackboneElement {
     _warningOnly?: Element;
     _sourceId?: Element;
     /** delete | get | options | patch | post | put | head */
-    requestMethod?: code;
+    requestMethod?: `${TestScriptSetupActionAssertRequestMethod}`;
     _compareToSourcePath?: Element;
     _minimumId?: Element;
     /** Request URL comparison value */
     requestURL?: string;
     /** response | request */
-    direction?: code;
+    direction?: `${TestScriptSetupActionAssertDirection}`;
     /** Perform validation on navigation links? */
     navigationLinks?: boolean;
 }
@@ -252,6 +495,16 @@ export interface TestScriptTest extends BackboneElement {
     /** A test operation or assert to perform */
     action: Array<TestScriptAction>;
 }
+/** delete | get | options | patch | post | put | head */
+export declare enum TestScriptSetupActionAssertRequestMethod {
+    Delete = "delete",
+    Get = "get",
+    Head = "head",
+    Options = "options",
+    Patch = "patch",
+    Post = "post",
+    Put = "put"
+}
 /** Capabilities  that are assumed to function correctly on the FHIR server being tested */
 export interface TestScriptCapability extends BackboneElement {
     /** The expected capabilities of the server */
@@ -276,11 +529,40 @@ export interface TestScriptCapability extends BackboneElement {
     /** Are the capabilities required? */
     required: boolean;
 }
+/** response | request */
+export declare enum TestScriptSetupActionAssertDirection {
+    Request = "request",
+    Response = "response"
+}
+/** equals | notEquals | in | notIn | greaterThan | lessThan | empty | notEmpty | contains | notContains | eval */
+export declare enum TestScriptSetupActionAssertOperator {
+    Empty = "empty",
+    NotEmpty = "notEmpty",
+    Contains = "contains",
+    NotEquals = "notEquals",
+    In = "in",
+    LessThan = "lessThan",
+    GreaterThan = "greaterThan",
+    Eval = "eval",
+    Equals = "equals",
+    NotIn = "notIn",
+    NotContains = "notContains"
+}
 /** A series of required setup operations before tests are executed */
 export interface TestScriptSetup extends BackboneElement {
     /** A setup operation or assert to perform */
     action: Array<TestScriptAction>;
 }
+/** delete | get | options | patch | post | put | head */
+export declare enum TestScriptSetupActionOperationMethod {
+    Delete = "delete",
+    Get = "get",
+    Head = "head",
+    Options = "options",
+    Patch = "patch",
+    Post = "post",
+    Put = "put"
+}
 /** A setup operation or assert to perform */
 export interface TestScriptAction extends BackboneElement {
     operation?: TestScriptSetupActionOperation;
@@ -295,6 +577,13 @@ export interface TestScriptSetupActionOperationRequestHeader extends BackboneEle
     value: string;
     _value?: Element;
 }
+/** draft | active | retired | unknown */
+export declare enum TestScriptStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
 /** Links to the FHIR specification */
 export interface TestScriptLink extends BackboneElement {
     /** URL to the specification */
@@ -320,6 +609,220 @@ export interface TestScriptTeardown extends BackboneElement {
     /** One or more teardown operations to perform */
     action: Array<TestScriptAction>;
 }
+/** Resource type */
+export declare enum TestScriptSetupActionAssertResource {
+    ImmunizationEvaluation = "ImmunizationEvaluation",
+    Appointment = "Appointment",
+    StructureMap = "StructureMap",
+    Address = "Address",
+    CareTeam = "CareTeam",
+    UsageContext = "UsageContext",
+    Linkage = "Linkage",
+    Annotation = "Annotation",
+    Age = "Age",
+    Attachment = "Attachment",
+    Communication = "Communication",
+    MedicationDispense = "MedicationDispense",
+    ImagingStudy = "ImagingStudy",
+    ChargeItem = "ChargeItem",
+    Period = "Period",
+    AdverseEvent = "AdverseEvent",
+    ContactDetail = "ContactDetail",
+    DataRequirement = "DataRequirement",
+    Media = "Media",
+    CodeableConcept = "CodeableConcept",
+    Uri = "uri",
+    SubstancePolymer = "SubstancePolymer",
+    QuestionnaireResponse = "QuestionnaireResponse",
+    Coverage = "Coverage",
+    Procedure = "Procedure",
+    AuditEvent = "AuditEvent",
+    PaymentReconciliation = "PaymentReconciliation",
+    MedicinalProductManufactured = "MedicinalProductManufactured",
+    CompartmentDefinition = "CompartmentDefinition",
+    Organization = "Organization",
+    ExplanationOfBenefit = "ExplanationOfBenefit",
+    Composition = "Composition",
+    SimpleQuantity = "SimpleQuantity",
+    CoverageEligibilityResponse = "CoverageEligibilityResponse",
+    DocumentReference = "DocumentReference",
+    EventDefinition = "EventDefinition",
+    SubstanceProtein = "SubstanceProtein",
+    TerminologyCapabilities = "TerminologyCapabilities",
+    Encounter = "Encounter",
+    ImplementationGuide = "ImplementationGuide",
+    EvidenceVariable = "EvidenceVariable",
+    ObservationDefinition = "ObservationDefinition",
+    DiagnosticReport = "DiagnosticReport",
+    ExampleScenario = "ExampleScenario",
+    ResearchDefinition = "ResearchDefinition",
+    Parameters = "Parameters",
+    Instant = "instant",
+    SearchParameter = "SearchParameter",
+    MedicinalProductInteraction = "MedicinalProductInteraction",
+    CodeSystem = "CodeSystem",
+    MessageDefinition = "MessageDefinition",
+    NutritionOrder = "NutritionOrder",
+    VerificationResult = "VerificationResult",
+    MedicationAdministration = "MedicationAdministration",
+    CatalogEntry = "CatalogEntry",
+    Flag = "Flag",
+    DeviceUseStatement = "DeviceUseStatement",
+    TriggerDefinition = "TriggerDefinition",
+    Contract = "Contract",
+    Invoice = "Invoice",
+    MarketingStatus = "MarketingStatus",
+    Count = "Count",
+    PaymentNotice = "PaymentNotice",
+    Location = "Location",
+    Claim = "Claim",
+    Specimen = "Specimen",
+    MedicationStatement = "MedicationStatement",
+    EnrollmentResponse = "EnrollmentResponse",
+    Uuid = "uuid",
+    Evidence = "Evidence",
+    Bundle = "Bundle",
+    ResearchElementDefinition = "ResearchElementDefinition",
+    Expression = "Expression",
+    Coding = "Coding",
+    BodyStructure = "BodyStructure",
+    MedicinalProduct = "MedicinalProduct",
+    Canonical = "canonical",
+    ResearchStudy = "ResearchStudy",
+    Dosage = "Dosage",
+    AppointmentResponse = "AppointmentResponse",
+    MedicinalProductIndication = "MedicinalProductIndication",
+    Measure = "Measure",
+    Person = "Person",
+    InsurancePlan = "InsurancePlan",
+    Date = "date",
+    Patient = "Patient",
+    EffectEvidenceSynthesis = "EffectEvidenceSynthesis",
+    ResearchSubject = "ResearchSubject",
+    Medication = "Medication",
+    Range = "Range",
+    ConceptMap = "ConceptMap",
+    CoverageEligibilityRequest = "CoverageEligibilityRequest",
+    Population = "Population",
+    SubstanceSourceMaterial = "SubstanceSourceMaterial",
+    VisionPrescription = "VisionPrescription",
+    MolecularSequence = "MolecularSequence",
+    MedicinalProductUndesirableEffect = "MedicinalProductUndesirableEffect",
+    OperationOutcome = "OperationOutcome",
+    MessageHeader = "MessageHeader",
+    ContactPoint = "ContactPoint",
+    Signature = "Signature",
+    Decimal = "decimal",
+    AllergyIntolerance = "AllergyIntolerance",
+    SubstanceReferenceInformation = "SubstanceReferenceInformation",
+    SupplyDelivery = "SupplyDelivery",
+    EpisodeOfCare = "EpisodeOfCare",
+    PractitionerRole = "PractitionerRole",
+    Library = "Library",
+    Practitioner = "Practitioner",
+    Markdown = "markdown",
+    MedicationRequest = "MedicationRequest",
+    ImmunizationRecommendation = "ImmunizationRecommendation",
+    RelatedArtifact = "RelatedArtifact",
+    Timing = "Timing",
+    Immunization = "Immunization",
+    GraphDefinition = "GraphDefinition",
+    Account = "Account",
+    Url = "url",
+    MedicinalProductIngredient = "MedicinalProductIngredient",
+    ProdCharacteristic = "ProdCharacteristic",
+    Meta = "Meta",
+    Quantity = "Quantity",
+    MeasureReport = "MeasureReport",
+    Distance = "Distance",
+    HumanName = "HumanName",
+    DeviceMetric = "DeviceMetric",
+    Duration = "Duration",
+    SubstanceAmount = "SubstanceAmount",
+    Goal = "Goal",
+    MedicationKnowledge = "MedicationKnowledge",
+    Integer = "integer",
+    String = "string",
+    ClaimResponse = "ClaimResponse",
+    DeviceDefinition = "DeviceDefinition",
+    Slot = "Slot",
+    ValueSet = "ValueSet",
+    MedicinalProductAuthorization = "MedicinalProductAuthorization",
+    StructureDefinition = "StructureDefinition",
+    Base64Binary = "base64Binary",
+    MedicinalProductContraindication = "MedicinalProductContraindication",
+    ElementDefinition = "ElementDefinition",
+    DeviceRequest = "DeviceRequest",
+    List = "List",
+    Questionnaire = "Questionnaire",
+    DomainResource = "DomainResource",
+    Endpoint = "Endpoint",
+    NamingSystem = "NamingSystem",
+    MedicinalProductPackaged = "MedicinalProductPackaged",
+    Basic = "Basic",
+    Money = "Money",
+    Binary = "Binary",
+    PlanDefinition = "PlanDefinition",
+    Subscription = "Subscription",
+    SampledData = "SampledData",
+    ProductShelfLife = "ProductShelfLife",
+    RelatedPerson = "RelatedPerson",
+    SubstanceSpecification = "SubstanceSpecification",
+    Ratio = "Ratio",
+    SubstanceNucleicAcid = "SubstanceNucleicAcid",
+    GuidanceResponse = "GuidanceResponse",
+    ClinicalImpression = "ClinicalImpression",
+    OrganizationAffiliation = "OrganizationAffiliation",
+    Resource = "Resource",
+    UnsignedInt = "unsignedInt",
+    Condition = "Condition",
+    Extension = "Extension",
+    CapabilityStatement = "CapabilityStatement",
+    HealthcareService = "HealthcareService",
+    SpecimenDefinition = "SpecimenDefinition",
+    ParameterDefinition = "ParameterDefinition",
+    RiskAssessment = "RiskAssessment",
+    Xhtml = "xhtml",
+    OperationDefinition = "OperationDefinition",
+    ActivityDefinition = "ActivityDefinition",
+    Schedule = "Schedule",
+    BiologicallyDerivedProduct = "BiologicallyDerivedProduct",
+    PositiveInt = "positiveInt",
+    Code = "code",
+    Group = "Group",
+    MedicinalProductPharmaceutical = "MedicinalProductPharmaceutical",
+    FamilyMemberHistory = "FamilyMemberHistory",
+    ServiceRequest = "ServiceRequest",
+    DetectedIssue = "DetectedIssue",
+    Device = "Device",
+    Oid = "oid",
+    RequestGroup = "RequestGroup",
+    TestScript = "TestScript",
+    RiskEvidenceSynthesis = "RiskEvidenceSynthesis",
+    SupplyRequest = "SupplyRequest",
+    Element = "Element",
+    Reference = "Reference",
+    Task = "Task",
+    Identifier = "Identifier",
+    CommunicationRequest = "CommunicationRequest",
+    EnrollmentRequest = "EnrollmentRequest",
+    ChargeItemDefinition = "ChargeItemDefinition",
+    Substance = "Substance",
+    Id = "id",
+    Provenance = "Provenance",
+    Time = "time",
+    Consent = "Consent",
+    BackboneElement = "BackboneElement",
+    CarePlan = "CarePlan",
+    Narrative = "Narrative",
+    MoneyQuantity = "MoneyQuantity",
+    TestReport = "TestReport",
+    Observation = "Observation",
+    DateTime = "dateTime",
+    Boolean = "boolean",
+    DocumentManifest = "DocumentManifest",
+    Contributor = "Contributor"
+}
 /** An abstract server representing a destination or receiver in a message exchange */
 export interface TestScriptDestination extends BackboneElement {
     /** The index of the abstract destination server starting at 1 */
@@ -328,3 +831,10 @@ export interface TestScriptDestination extends BackboneElement {
     /** FHIR-Server | FHIR-SDC-FormManager | FHIR-SDC-FormReceiver | FHIR-SDC-FormProcessor */
     profile: Coding;
 }
+/** Mime type to accept in the payload of the response, with charset etc. */
+export declare enum TestScriptSetupActionOperationAccept {
+    "Application/hl7Cda+xml" = "application/hl7-cda+xml",
+    "Application/sparqlResults+xml" = "application/sparql-results+xml",
+    "Application/sql" = "application/sql",
+    "Application/xquery" = "application/xquery"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/TestScript.js b/vendor/r4/types/hl7-fhir-r4-core/TestScript.js
index c8ad2e5..fcf0f94 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/TestScript.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/TestScript.js
@@ -1,2 +1,524 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestScriptSetupActionOperationAccept = exports.TestScriptSetupActionAssertResource = exports.TestScriptStatus = exports.TestScriptSetupActionOperationMethod = exports.TestScriptSetupActionAssertOperator = exports.TestScriptSetupActionAssertDirection = exports.TestScriptSetupActionAssertRequestMethod = exports.TestScriptSetupActionAssertContentType = exports.TestScriptSetupActionAssertResponse = exports.TestScriptSetupActionOperationResource = exports.TestScriptSetupActionOperationContentType = void 0;
+/** Mime type of the request payload contents, with charset etc. */
+var TestScriptSetupActionOperationContentType;
+(function (TestScriptSetupActionOperationContentType) {
+    TestScriptSetupActionOperationContentType["Application/hl7Cda+xml"] = "application/hl7-cda+xml";
+    TestScriptSetupActionOperationContentType["Application/sparqlResults+xml"] = "application/sparql-results+xml";
+    TestScriptSetupActionOperationContentType["Application/sql"] = "application/sql";
+    TestScriptSetupActionOperationContentType["Application/xquery"] = "application/xquery";
+})(TestScriptSetupActionOperationContentType = exports.TestScriptSetupActionOperationContentType || (exports.TestScriptSetupActionOperationContentType = {}));
+/** Resource type */
+var TestScriptSetupActionOperationResource;
+(function (TestScriptSetupActionOperationResource) {
+    TestScriptSetupActionOperationResource["ImmunizationEvaluation"] = "ImmunizationEvaluation";
+    TestScriptSetupActionOperationResource["Appointment"] = "Appointment";
+    TestScriptSetupActionOperationResource["StructureMap"] = "StructureMap";
+    TestScriptSetupActionOperationResource["Address"] = "Address";
+    TestScriptSetupActionOperationResource["CareTeam"] = "CareTeam";
+    TestScriptSetupActionOperationResource["UsageContext"] = "UsageContext";
+    TestScriptSetupActionOperationResource["Linkage"] = "Linkage";
+    TestScriptSetupActionOperationResource["Annotation"] = "Annotation";
+    TestScriptSetupActionOperationResource["Age"] = "Age";
+    TestScriptSetupActionOperationResource["Attachment"] = "Attachment";
+    TestScriptSetupActionOperationResource["Communication"] = "Communication";
+    TestScriptSetupActionOperationResource["MedicationDispense"] = "MedicationDispense";
+    TestScriptSetupActionOperationResource["ImagingStudy"] = "ImagingStudy";
+    TestScriptSetupActionOperationResource["ChargeItem"] = "ChargeItem";
+    TestScriptSetupActionOperationResource["Period"] = "Period";
+    TestScriptSetupActionOperationResource["AdverseEvent"] = "AdverseEvent";
+    TestScriptSetupActionOperationResource["ContactDetail"] = "ContactDetail";
+    TestScriptSetupActionOperationResource["DataRequirement"] = "DataRequirement";
+    TestScriptSetupActionOperationResource["Media"] = "Media";
+    TestScriptSetupActionOperationResource["CodeableConcept"] = "CodeableConcept";
+    TestScriptSetupActionOperationResource["Uri"] = "uri";
+    TestScriptSetupActionOperationResource["SubstancePolymer"] = "SubstancePolymer";
+    TestScriptSetupActionOperationResource["QuestionnaireResponse"] = "QuestionnaireResponse";
+    TestScriptSetupActionOperationResource["Coverage"] = "Coverage";
+    TestScriptSetupActionOperationResource["Procedure"] = "Procedure";
+    TestScriptSetupActionOperationResource["AuditEvent"] = "AuditEvent";
+    TestScriptSetupActionOperationResource["PaymentReconciliation"] = "PaymentReconciliation";
+    TestScriptSetupActionOperationResource["MedicinalProductManufactured"] = "MedicinalProductManufactured";
+    TestScriptSetupActionOperationResource["CompartmentDefinition"] = "CompartmentDefinition";
+    TestScriptSetupActionOperationResource["Organization"] = "Organization";
+    TestScriptSetupActionOperationResource["ExplanationOfBenefit"] = "ExplanationOfBenefit";
+    TestScriptSetupActionOperationResource["Composition"] = "Composition";
+    TestScriptSetupActionOperationResource["SimpleQuantity"] = "SimpleQuantity";
+    TestScriptSetupActionOperationResource["CoverageEligibilityResponse"] = "CoverageEligibilityResponse";
+    TestScriptSetupActionOperationResource["DocumentReference"] = "DocumentReference";
+    TestScriptSetupActionOperationResource["EventDefinition"] = "EventDefinition";
+    TestScriptSetupActionOperationResource["SubstanceProtein"] = "SubstanceProtein";
+    TestScriptSetupActionOperationResource["TerminologyCapabilities"] = "TerminologyCapabilities";
+    TestScriptSetupActionOperationResource["Encounter"] = "Encounter";
+    TestScriptSetupActionOperationResource["ImplementationGuide"] = "ImplementationGuide";
+    TestScriptSetupActionOperationResource["EvidenceVariable"] = "EvidenceVariable";
+    TestScriptSetupActionOperationResource["ObservationDefinition"] = "ObservationDefinition";
+    TestScriptSetupActionOperationResource["DiagnosticReport"] = "DiagnosticReport";
+    TestScriptSetupActionOperationResource["ExampleScenario"] = "ExampleScenario";
+    TestScriptSetupActionOperationResource["ResearchDefinition"] = "ResearchDefinition";
+    TestScriptSetupActionOperationResource["Parameters"] = "Parameters";
+    TestScriptSetupActionOperationResource["Instant"] = "instant";
+    TestScriptSetupActionOperationResource["SearchParameter"] = "SearchParameter";
+    TestScriptSetupActionOperationResource["MedicinalProductInteraction"] = "MedicinalProductInteraction";
+    TestScriptSetupActionOperationResource["CodeSystem"] = "CodeSystem";
+    TestScriptSetupActionOperationResource["MessageDefinition"] = "MessageDefinition";
+    TestScriptSetupActionOperationResource["NutritionOrder"] = "NutritionOrder";
+    TestScriptSetupActionOperationResource["VerificationResult"] = "VerificationResult";
+    TestScriptSetupActionOperationResource["MedicationAdministration"] = "MedicationAdministration";
+    TestScriptSetupActionOperationResource["CatalogEntry"] = "CatalogEntry";
+    TestScriptSetupActionOperationResource["Flag"] = "Flag";
+    TestScriptSetupActionOperationResource["DeviceUseStatement"] = "DeviceUseStatement";
+    TestScriptSetupActionOperationResource["TriggerDefinition"] = "TriggerDefinition";
+    TestScriptSetupActionOperationResource["Contract"] = "Contract";
+    TestScriptSetupActionOperationResource["Invoice"] = "Invoice";
+    TestScriptSetupActionOperationResource["MarketingStatus"] = "MarketingStatus";
+    TestScriptSetupActionOperationResource["Count"] = "Count";
+    TestScriptSetupActionOperationResource["PaymentNotice"] = "PaymentNotice";
+    TestScriptSetupActionOperationResource["Location"] = "Location";
+    TestScriptSetupActionOperationResource["Claim"] = "Claim";
+    TestScriptSetupActionOperationResource["Specimen"] = "Specimen";
+    TestScriptSetupActionOperationResource["MedicationStatement"] = "MedicationStatement";
+    TestScriptSetupActionOperationResource["EnrollmentResponse"] = "EnrollmentResponse";
+    TestScriptSetupActionOperationResource["Uuid"] = "uuid";
+    TestScriptSetupActionOperationResource["Evidence"] = "Evidence";
+    TestScriptSetupActionOperationResource["Bundle"] = "Bundle";
+    TestScriptSetupActionOperationResource["ResearchElementDefinition"] = "ResearchElementDefinition";
+    TestScriptSetupActionOperationResource["Expression"] = "Expression";
+    TestScriptSetupActionOperationResource["Coding"] = "Coding";
+    TestScriptSetupActionOperationResource["BodyStructure"] = "BodyStructure";
+    TestScriptSetupActionOperationResource["MedicinalProduct"] = "MedicinalProduct";
+    TestScriptSetupActionOperationResource["Canonical"] = "canonical";
+    TestScriptSetupActionOperationResource["ResearchStudy"] = "ResearchStudy";
+    TestScriptSetupActionOperationResource["Dosage"] = "Dosage";
+    TestScriptSetupActionOperationResource["AppointmentResponse"] = "AppointmentResponse";
+    TestScriptSetupActionOperationResource["MedicinalProductIndication"] = "MedicinalProductIndication";
+    TestScriptSetupActionOperationResource["Measure"] = "Measure";
+    TestScriptSetupActionOperationResource["Person"] = "Person";
+    TestScriptSetupActionOperationResource["InsurancePlan"] = "InsurancePlan";
+    TestScriptSetupActionOperationResource["Date"] = "date";
+    TestScriptSetupActionOperationResource["Patient"] = "Patient";
+    TestScriptSetupActionOperationResource["EffectEvidenceSynthesis"] = "EffectEvidenceSynthesis";
+    TestScriptSetupActionOperationResource["ResearchSubject"] = "ResearchSubject";
+    TestScriptSetupActionOperationResource["Medication"] = "Medication";
+    TestScriptSetupActionOperationResource["Range"] = "Range";
+    TestScriptSetupActionOperationResource["ConceptMap"] = "ConceptMap";
+    TestScriptSetupActionOperationResource["CoverageEligibilityRequest"] = "CoverageEligibilityRequest";
+    TestScriptSetupActionOperationResource["Population"] = "Population";
+    TestScriptSetupActionOperationResource["SubstanceSourceMaterial"] = "SubstanceSourceMaterial";
+    TestScriptSetupActionOperationResource["VisionPrescription"] = "VisionPrescription";
+    TestScriptSetupActionOperationResource["MolecularSequence"] = "MolecularSequence";
+    TestScriptSetupActionOperationResource["MedicinalProductUndesirableEffect"] = "MedicinalProductUndesirableEffect";
+    TestScriptSetupActionOperationResource["OperationOutcome"] = "OperationOutcome";
+    TestScriptSetupActionOperationResource["MessageHeader"] = "MessageHeader";
+    TestScriptSetupActionOperationResource["ContactPoint"] = "ContactPoint";
+    TestScriptSetupActionOperationResource["Signature"] = "Signature";
+    TestScriptSetupActionOperationResource["Decimal"] = "decimal";
+    TestScriptSetupActionOperationResource["AllergyIntolerance"] = "AllergyIntolerance";
+    TestScriptSetupActionOperationResource["SubstanceReferenceInformation"] = "SubstanceReferenceInformation";
+    TestScriptSetupActionOperationResource["SupplyDelivery"] = "SupplyDelivery";
+    TestScriptSetupActionOperationResource["EpisodeOfCare"] = "EpisodeOfCare";
+    TestScriptSetupActionOperationResource["PractitionerRole"] = "PractitionerRole";
+    TestScriptSetupActionOperationResource["Library"] = "Library";
+    TestScriptSetupActionOperationResource["Practitioner"] = "Practitioner";
+    TestScriptSetupActionOperationResource["Markdown"] = "markdown";
+    TestScriptSetupActionOperationResource["MedicationRequest"] = "MedicationRequest";
+    TestScriptSetupActionOperationResource["ImmunizationRecommendation"] = "ImmunizationRecommendation";
+    TestScriptSetupActionOperationResource["RelatedArtifact"] = "RelatedArtifact";
+    TestScriptSetupActionOperationResource["Timing"] = "Timing";
+    TestScriptSetupActionOperationResource["Immunization"] = "Immunization";
+    TestScriptSetupActionOperationResource["GraphDefinition"] = "GraphDefinition";
+    TestScriptSetupActionOperationResource["Account"] = "Account";
+    TestScriptSetupActionOperationResource["Url"] = "url";
+    TestScriptSetupActionOperationResource["MedicinalProductIngredient"] = "MedicinalProductIngredient";
+    TestScriptSetupActionOperationResource["ProdCharacteristic"] = "ProdCharacteristic";
+    TestScriptSetupActionOperationResource["Meta"] = "Meta";
+    TestScriptSetupActionOperationResource["Quantity"] = "Quantity";
+    TestScriptSetupActionOperationResource["MeasureReport"] = "MeasureReport";
+    TestScriptSetupActionOperationResource["Distance"] = "Distance";
+    TestScriptSetupActionOperationResource["HumanName"] = "HumanName";
+    TestScriptSetupActionOperationResource["DeviceMetric"] = "DeviceMetric";
+    TestScriptSetupActionOperationResource["Duration"] = "Duration";
+    TestScriptSetupActionOperationResource["SubstanceAmount"] = "SubstanceAmount";
+    TestScriptSetupActionOperationResource["Goal"] = "Goal";
+    TestScriptSetupActionOperationResource["MedicationKnowledge"] = "MedicationKnowledge";
+    TestScriptSetupActionOperationResource["Integer"] = "integer";
+    TestScriptSetupActionOperationResource["String"] = "string";
+    TestScriptSetupActionOperationResource["ClaimResponse"] = "ClaimResponse";
+    TestScriptSetupActionOperationResource["DeviceDefinition"] = "DeviceDefinition";
+    TestScriptSetupActionOperationResource["Slot"] = "Slot";
+    TestScriptSetupActionOperationResource["ValueSet"] = "ValueSet";
+    TestScriptSetupActionOperationResource["MedicinalProductAuthorization"] = "MedicinalProductAuthorization";
+    TestScriptSetupActionOperationResource["StructureDefinition"] = "StructureDefinition";
+    TestScriptSetupActionOperationResource["Base64Binary"] = "base64Binary";
+    TestScriptSetupActionOperationResource["MedicinalProductContraindication"] = "MedicinalProductContraindication";
+    TestScriptSetupActionOperationResource["ElementDefinition"] = "ElementDefinition";
+    TestScriptSetupActionOperationResource["DeviceRequest"] = "DeviceRequest";
+    TestScriptSetupActionOperationResource["List"] = "List";
+    TestScriptSetupActionOperationResource["Questionnaire"] = "Questionnaire";
+    TestScriptSetupActionOperationResource["DomainResource"] = "DomainResource";
+    TestScriptSetupActionOperationResource["Endpoint"] = "Endpoint";
+    TestScriptSetupActionOperationResource["NamingSystem"] = "NamingSystem";
+    TestScriptSetupActionOperationResource["MedicinalProductPackaged"] = "MedicinalProductPackaged";
+    TestScriptSetupActionOperationResource["Basic"] = "Basic";
+    TestScriptSetupActionOperationResource["Money"] = "Money";
+    TestScriptSetupActionOperationResource["Binary"] = "Binary";
+    TestScriptSetupActionOperationResource["PlanDefinition"] = "PlanDefinition";
+    TestScriptSetupActionOperationResource["Subscription"] = "Subscription";
+    TestScriptSetupActionOperationResource["SampledData"] = "SampledData";
+    TestScriptSetupActionOperationResource["ProductShelfLife"] = "ProductShelfLife";
+    TestScriptSetupActionOperationResource["RelatedPerson"] = "RelatedPerson";
+    TestScriptSetupActionOperationResource["SubstanceSpecification"] = "SubstanceSpecification";
+    TestScriptSetupActionOperationResource["Ratio"] = "Ratio";
+    TestScriptSetupActionOperationResource["SubstanceNucleicAcid"] = "SubstanceNucleicAcid";
+    TestScriptSetupActionOperationResource["GuidanceResponse"] = "GuidanceResponse";
+    TestScriptSetupActionOperationResource["ClinicalImpression"] = "ClinicalImpression";
+    TestScriptSetupActionOperationResource["OrganizationAffiliation"] = "OrganizationAffiliation";
+    TestScriptSetupActionOperationResource["Resource"] = "Resource";
+    TestScriptSetupActionOperationResource["UnsignedInt"] = "unsignedInt";
+    TestScriptSetupActionOperationResource["Condition"] = "Condition";
+    TestScriptSetupActionOperationResource["Extension"] = "Extension";
+    TestScriptSetupActionOperationResource["CapabilityStatement"] = "CapabilityStatement";
+    TestScriptSetupActionOperationResource["HealthcareService"] = "HealthcareService";
+    TestScriptSetupActionOperationResource["SpecimenDefinition"] = "SpecimenDefinition";
+    TestScriptSetupActionOperationResource["ParameterDefinition"] = "ParameterDefinition";
+    TestScriptSetupActionOperationResource["RiskAssessment"] = "RiskAssessment";
+    TestScriptSetupActionOperationResource["Xhtml"] = "xhtml";
+    TestScriptSetupActionOperationResource["OperationDefinition"] = "OperationDefinition";
+    TestScriptSetupActionOperationResource["ActivityDefinition"] = "ActivityDefinition";
+    TestScriptSetupActionOperationResource["Schedule"] = "Schedule";
+    TestScriptSetupActionOperationResource["BiologicallyDerivedProduct"] = "BiologicallyDerivedProduct";
+    TestScriptSetupActionOperationResource["PositiveInt"] = "positiveInt";
+    TestScriptSetupActionOperationResource["Code"] = "code";
+    TestScriptSetupActionOperationResource["Group"] = "Group";
+    TestScriptSetupActionOperationResource["MedicinalProductPharmaceutical"] = "MedicinalProductPharmaceutical";
+    TestScriptSetupActionOperationResource["FamilyMemberHistory"] = "FamilyMemberHistory";
+    TestScriptSetupActionOperationResource["ServiceRequest"] = "ServiceRequest";
+    TestScriptSetupActionOperationResource["DetectedIssue"] = "DetectedIssue";
+    TestScriptSetupActionOperationResource["Device"] = "Device";
+    TestScriptSetupActionOperationResource["Oid"] = "oid";
+    TestScriptSetupActionOperationResource["RequestGroup"] = "RequestGroup";
+    TestScriptSetupActionOperationResource["TestScript"] = "TestScript";
+    TestScriptSetupActionOperationResource["RiskEvidenceSynthesis"] = "RiskEvidenceSynthesis";
+    TestScriptSetupActionOperationResource["SupplyRequest"] = "SupplyRequest";
+    TestScriptSetupActionOperationResource["Element"] = "Element";
+    TestScriptSetupActionOperationResource["Reference"] = "Reference";
+    TestScriptSetupActionOperationResource["Task"] = "Task";
+    TestScriptSetupActionOperationResource["Identifier"] = "Identifier";
+    TestScriptSetupActionOperationResource["CommunicationRequest"] = "CommunicationRequest";
+    TestScriptSetupActionOperationResource["EnrollmentRequest"] = "EnrollmentRequest";
+    TestScriptSetupActionOperationResource["ChargeItemDefinition"] = "ChargeItemDefinition";
+    TestScriptSetupActionOperationResource["Substance"] = "Substance";
+    TestScriptSetupActionOperationResource["Id"] = "id";
+    TestScriptSetupActionOperationResource["Provenance"] = "Provenance";
+    TestScriptSetupActionOperationResource["Time"] = "time";
+    TestScriptSetupActionOperationResource["Consent"] = "Consent";
+    TestScriptSetupActionOperationResource["BackboneElement"] = "BackboneElement";
+    TestScriptSetupActionOperationResource["CarePlan"] = "CarePlan";
+    TestScriptSetupActionOperationResource["Narrative"] = "Narrative";
+    TestScriptSetupActionOperationResource["MoneyQuantity"] = "MoneyQuantity";
+    TestScriptSetupActionOperationResource["TestReport"] = "TestReport";
+    TestScriptSetupActionOperationResource["Observation"] = "Observation";
+    TestScriptSetupActionOperationResource["DateTime"] = "dateTime";
+    TestScriptSetupActionOperationResource["Boolean"] = "boolean";
+    TestScriptSetupActionOperationResource["DocumentManifest"] = "DocumentManifest";
+    TestScriptSetupActionOperationResource["Contributor"] = "Contributor";
+})(TestScriptSetupActionOperationResource = exports.TestScriptSetupActionOperationResource || (exports.TestScriptSetupActionOperationResource = {}));
+/** okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable */
+var TestScriptSetupActionAssertResponse;
+(function (TestScriptSetupActionAssertResponse) {
+    TestScriptSetupActionAssertResponse["Unprocessable"] = "unprocessable";
+    TestScriptSetupActionAssertResponse["Created"] = "created";
+    TestScriptSetupActionAssertResponse["NotFound"] = "notFound";
+    TestScriptSetupActionAssertResponse["MethodNotAllowed"] = "methodNotAllowed";
+    TestScriptSetupActionAssertResponse["Conflict"] = "conflict";
+    TestScriptSetupActionAssertResponse["Gone"] = "gone";
+    TestScriptSetupActionAssertResponse["Bad"] = "bad";
+    TestScriptSetupActionAssertResponse["PreconditionFailed"] = "preconditionFailed";
+    TestScriptSetupActionAssertResponse["Okay"] = "okay";
+    TestScriptSetupActionAssertResponse["NoContent"] = "noContent";
+    TestScriptSetupActionAssertResponse["Forbidden"] = "forbidden";
+    TestScriptSetupActionAssertResponse["NotModified"] = "notModified";
+})(TestScriptSetupActionAssertResponse = exports.TestScriptSetupActionAssertResponse || (exports.TestScriptSetupActionAssertResponse = {}));
+/** Mime type to compare against the 'Content-Type' header */
+var TestScriptSetupActionAssertContentType;
+(function (TestScriptSetupActionAssertContentType) {
+    TestScriptSetupActionAssertContentType["Application/hl7Cda+xml"] = "application/hl7-cda+xml";
+    TestScriptSetupActionAssertContentType["Application/sparqlResults+xml"] = "application/sparql-results+xml";
+    TestScriptSetupActionAssertContentType["Application/sql"] = "application/sql";
+    TestScriptSetupActionAssertContentType["Application/xquery"] = "application/xquery";
+})(TestScriptSetupActionAssertContentType = exports.TestScriptSetupActionAssertContentType || (exports.TestScriptSetupActionAssertContentType = {}));
+/** delete | get | options | patch | post | put | head */
+var TestScriptSetupActionAssertRequestMethod;
+(function (TestScriptSetupActionAssertRequestMethod) {
+    TestScriptSetupActionAssertRequestMethod["Delete"] = "delete";
+    TestScriptSetupActionAssertRequestMethod["Get"] = "get";
+    TestScriptSetupActionAssertRequestMethod["Head"] = "head";
+    TestScriptSetupActionAssertRequestMethod["Options"] = "options";
+    TestScriptSetupActionAssertRequestMethod["Patch"] = "patch";
+    TestScriptSetupActionAssertRequestMethod["Post"] = "post";
+    TestScriptSetupActionAssertRequestMethod["Put"] = "put";
+})(TestScriptSetupActionAssertRequestMethod = exports.TestScriptSetupActionAssertRequestMethod || (exports.TestScriptSetupActionAssertRequestMethod = {}));
+/** response | request */
+var TestScriptSetupActionAssertDirection;
+(function (TestScriptSetupActionAssertDirection) {
+    TestScriptSetupActionAssertDirection["Request"] = "request";
+    TestScriptSetupActionAssertDirection["Response"] = "response";
+})(TestScriptSetupActionAssertDirection = exports.TestScriptSetupActionAssertDirection || (exports.TestScriptSetupActionAssertDirection = {}));
+/** equals | notEquals | in | notIn | greaterThan | lessThan | empty | notEmpty | contains | notContains | eval */
+var TestScriptSetupActionAssertOperator;
+(function (TestScriptSetupActionAssertOperator) {
+    TestScriptSetupActionAssertOperator["Empty"] = "empty";
+    TestScriptSetupActionAssertOperator["NotEmpty"] = "notEmpty";
+    TestScriptSetupActionAssertOperator["Contains"] = "contains";
+    TestScriptSetupActionAssertOperator["NotEquals"] = "notEquals";
+    TestScriptSetupActionAssertOperator["In"] = "in";
+    TestScriptSetupActionAssertOperator["LessThan"] = "lessThan";
+    TestScriptSetupActionAssertOperator["GreaterThan"] = "greaterThan";
+    TestScriptSetupActionAssertOperator["Eval"] = "eval";
+    TestScriptSetupActionAssertOperator["Equals"] = "equals";
+    TestScriptSetupActionAssertOperator["NotIn"] = "notIn";
+    TestScriptSetupActionAssertOperator["NotContains"] = "notContains";
+})(TestScriptSetupActionAssertOperator = exports.TestScriptSetupActionAssertOperator || (exports.TestScriptSetupActionAssertOperator = {}));
+/** delete | get | options | patch | post | put | head */
+var TestScriptSetupActionOperationMethod;
+(function (TestScriptSetupActionOperationMethod) {
+    TestScriptSetupActionOperationMethod["Delete"] = "delete";
+    TestScriptSetupActionOperationMethod["Get"] = "get";
+    TestScriptSetupActionOperationMethod["Head"] = "head";
+    TestScriptSetupActionOperationMethod["Options"] = "options";
+    TestScriptSetupActionOperationMethod["Patch"] = "patch";
+    TestScriptSetupActionOperationMethod["Post"] = "post";
+    TestScriptSetupActionOperationMethod["Put"] = "put";
+})(TestScriptSetupActionOperationMethod = exports.TestScriptSetupActionOperationMethod || (exports.TestScriptSetupActionOperationMethod = {}));
+/** draft | active | retired | unknown */
+var TestScriptStatus;
+(function (TestScriptStatus) {
+    TestScriptStatus["Active"] = "active";
+    TestScriptStatus["Draft"] = "draft";
+    TestScriptStatus["Retired"] = "retired";
+    TestScriptStatus["Unknown"] = "unknown";
+})(TestScriptStatus = exports.TestScriptStatus || (exports.TestScriptStatus = {}));
+/** Resource type */
+var TestScriptSetupActionAssertResource;
+(function (TestScriptSetupActionAssertResource) {
+    TestScriptSetupActionAssertResource["ImmunizationEvaluation"] = "ImmunizationEvaluation";
+    TestScriptSetupActionAssertResource["Appointment"] = "Appointment";
+    TestScriptSetupActionAssertResource["StructureMap"] = "StructureMap";
+    TestScriptSetupActionAssertResource["Address"] = "Address";
+    TestScriptSetupActionAssertResource["CareTeam"] = "CareTeam";
+    TestScriptSetupActionAssertResource["UsageContext"] = "UsageContext";
+    TestScriptSetupActionAssertResource["Linkage"] = "Linkage";
+    TestScriptSetupActionAssertResource["Annotation"] = "Annotation";
+    TestScriptSetupActionAssertResource["Age"] = "Age";
+    TestScriptSetupActionAssertResource["Attachment"] = "Attachment";
+    TestScriptSetupActionAssertResource["Communication"] = "Communication";
+    TestScriptSetupActionAssertResource["MedicationDispense"] = "MedicationDispense";
+    TestScriptSetupActionAssertResource["ImagingStudy"] = "ImagingStudy";
+    TestScriptSetupActionAssertResource["ChargeItem"] = "ChargeItem";
+    TestScriptSetupActionAssertResource["Period"] = "Period";
+    TestScriptSetupActionAssertResource["AdverseEvent"] = "AdverseEvent";
+    TestScriptSetupActionAssertResource["ContactDetail"] = "ContactDetail";
+    TestScriptSetupActionAssertResource["DataRequirement"] = "DataRequirement";
+    TestScriptSetupActionAssertResource["Media"] = "Media";
+    TestScriptSetupActionAssertResource["CodeableConcept"] = "CodeableConcept";
+    TestScriptSetupActionAssertResource["Uri"] = "uri";
+    TestScriptSetupActionAssertResource["SubstancePolymer"] = "SubstancePolymer";
+    TestScriptSetupActionAssertResource["QuestionnaireResponse"] = "QuestionnaireResponse";
+    TestScriptSetupActionAssertResource["Coverage"] = "Coverage";
+    TestScriptSetupActionAssertResource["Procedure"] = "Procedure";
+    TestScriptSetupActionAssertResource["AuditEvent"] = "AuditEvent";
+    TestScriptSetupActionAssertResource["PaymentReconciliation"] = "PaymentReconciliation";
+    TestScriptSetupActionAssertResource["MedicinalProductManufactured"] = "MedicinalProductManufactured";
+    TestScriptSetupActionAssertResource["CompartmentDefinition"] = "CompartmentDefinition";
+    TestScriptSetupActionAssertResource["Organization"] = "Organization";
+    TestScriptSetupActionAssertResource["ExplanationOfBenefit"] = "ExplanationOfBenefit";
+    TestScriptSetupActionAssertResource["Composition"] = "Composition";
+    TestScriptSetupActionAssertResource["SimpleQuantity"] = "SimpleQuantity";
+    TestScriptSetupActionAssertResource["CoverageEligibilityResponse"] = "CoverageEligibilityResponse";
+    TestScriptSetupActionAssertResource["DocumentReference"] = "DocumentReference";
+    TestScriptSetupActionAssertResource["EventDefinition"] = "EventDefinition";
+    TestScriptSetupActionAssertResource["SubstanceProtein"] = "SubstanceProtein";
+    TestScriptSetupActionAssertResource["TerminologyCapabilities"] = "TerminologyCapabilities";
+    TestScriptSetupActionAssertResource["Encounter"] = "Encounter";
+    TestScriptSetupActionAssertResource["ImplementationGuide"] = "ImplementationGuide";
+    TestScriptSetupActionAssertResource["EvidenceVariable"] = "EvidenceVariable";
+    TestScriptSetupActionAssertResource["ObservationDefinition"] = "ObservationDefinition";
+    TestScriptSetupActionAssertResource["DiagnosticReport"] = "DiagnosticReport";
+    TestScriptSetupActionAssertResource["ExampleScenario"] = "ExampleScenario";
+    TestScriptSetupActionAssertResource["ResearchDefinition"] = "ResearchDefinition";
+    TestScriptSetupActionAssertResource["Parameters"] = "Parameters";
+    TestScriptSetupActionAssertResource["Instant"] = "instant";
+    TestScriptSetupActionAssertResource["SearchParameter"] = "SearchParameter";
+    TestScriptSetupActionAssertResource["MedicinalProductInteraction"] = "MedicinalProductInteraction";
+    TestScriptSetupActionAssertResource["CodeSystem"] = "CodeSystem";
+    TestScriptSetupActionAssertResource["MessageDefinition"] = "MessageDefinition";
+    TestScriptSetupActionAssertResource["NutritionOrder"] = "NutritionOrder";
+    TestScriptSetupActionAssertResource["VerificationResult"] = "VerificationResult";
+    TestScriptSetupActionAssertResource["MedicationAdministration"] = "MedicationAdministration";
+    TestScriptSetupActionAssertResource["CatalogEntry"] = "CatalogEntry";
+    TestScriptSetupActionAssertResource["Flag"] = "Flag";
+    TestScriptSetupActionAssertResource["DeviceUseStatement"] = "DeviceUseStatement";
+    TestScriptSetupActionAssertResource["TriggerDefinition"] = "TriggerDefinition";
+    TestScriptSetupActionAssertResource["Contract"] = "Contract";
+    TestScriptSetupActionAssertResource["Invoice"] = "Invoice";
+    TestScriptSetupActionAssertResource["MarketingStatus"] = "MarketingStatus";
+    TestScriptSetupActionAssertResource["Count"] = "Count";
+    TestScriptSetupActionAssertResource["PaymentNotice"] = "PaymentNotice";
+    TestScriptSetupActionAssertResource["Location"] = "Location";
+    TestScriptSetupActionAssertResource["Claim"] = "Claim";
+    TestScriptSetupActionAssertResource["Specimen"] = "Specimen";
+    TestScriptSetupActionAssertResource["MedicationStatement"] = "MedicationStatement";
+    TestScriptSetupActionAssertResource["EnrollmentResponse"] = "EnrollmentResponse";
+    TestScriptSetupActionAssertResource["Uuid"] = "uuid";
+    TestScriptSetupActionAssertResource["Evidence"] = "Evidence";
+    TestScriptSetupActionAssertResource["Bundle"] = "Bundle";
+    TestScriptSetupActionAssertResource["ResearchElementDefinition"] = "ResearchElementDefinition";
+    TestScriptSetupActionAssertResource["Expression"] = "Expression";
+    TestScriptSetupActionAssertResource["Coding"] = "Coding";
+    TestScriptSetupActionAssertResource["BodyStructure"] = "BodyStructure";
+    TestScriptSetupActionAssertResource["MedicinalProduct"] = "MedicinalProduct";
+    TestScriptSetupActionAssertResource["Canonical"] = "canonical";
+    TestScriptSetupActionAssertResource["ResearchStudy"] = "ResearchStudy";
+    TestScriptSetupActionAssertResource["Dosage"] = "Dosage";
+    TestScriptSetupActionAssertResource["AppointmentResponse"] = "AppointmentResponse";
+    TestScriptSetupActionAssertResource["MedicinalProductIndication"] = "MedicinalProductIndication";
+    TestScriptSetupActionAssertResource["Measure"] = "Measure";
+    TestScriptSetupActionAssertResource["Person"] = "Person";
+    TestScriptSetupActionAssertResource["InsurancePlan"] = "InsurancePlan";
+    TestScriptSetupActionAssertResource["Date"] = "date";
+    TestScriptSetupActionAssertResource["Patient"] = "Patient";
+    TestScriptSetupActionAssertResource["EffectEvidenceSynthesis"] = "EffectEvidenceSynthesis";
+    TestScriptSetupActionAssertResource["ResearchSubject"] = "ResearchSubject";
+    TestScriptSetupActionAssertResource["Medication"] = "Medication";
+    TestScriptSetupActionAssertResource["Range"] = "Range";
+    TestScriptSetupActionAssertResource["ConceptMap"] = "ConceptMap";
+    TestScriptSetupActionAssertResource["CoverageEligibilityRequest"] = "CoverageEligibilityRequest";
+    TestScriptSetupActionAssertResource["Population"] = "Population";
+    TestScriptSetupActionAssertResource["SubstanceSourceMaterial"] = "SubstanceSourceMaterial";
+    TestScriptSetupActionAssertResource["VisionPrescription"] = "VisionPrescription";
+    TestScriptSetupActionAssertResource["MolecularSequence"] = "MolecularSequence";
+    TestScriptSetupActionAssertResource["MedicinalProductUndesirableEffect"] = "MedicinalProductUndesirableEffect";
+    TestScriptSetupActionAssertResource["OperationOutcome"] = "OperationOutcome";
+    TestScriptSetupActionAssertResource["MessageHeader"] = "MessageHeader";
+    TestScriptSetupActionAssertResource["ContactPoint"] = "ContactPoint";
+    TestScriptSetupActionAssertResource["Signature"] = "Signature";
+    TestScriptSetupActionAssertResource["Decimal"] = "decimal";
+    TestScriptSetupActionAssertResource["AllergyIntolerance"] = "AllergyIntolerance";
+    TestScriptSetupActionAssertResource["SubstanceReferenceInformation"] = "SubstanceReferenceInformation";
+    TestScriptSetupActionAssertResource["SupplyDelivery"] = "SupplyDelivery";
+    TestScriptSetupActionAssertResource["EpisodeOfCare"] = "EpisodeOfCare";
+    TestScriptSetupActionAssertResource["PractitionerRole"] = "PractitionerRole";
+    TestScriptSetupActionAssertResource["Library"] = "Library";
+    TestScriptSetupActionAssertResource["Practitioner"] = "Practitioner";
+    TestScriptSetupActionAssertResource["Markdown"] = "markdown";
+    TestScriptSetupActionAssertResource["MedicationRequest"] = "MedicationRequest";
+    TestScriptSetupActionAssertResource["ImmunizationRecommendation"] = "ImmunizationRecommendation";
+    TestScriptSetupActionAssertResource["RelatedArtifact"] = "RelatedArtifact";
+    TestScriptSetupActionAssertResource["Timing"] = "Timing";
+    TestScriptSetupActionAssertResource["Immunization"] = "Immunization";
+    TestScriptSetupActionAssertResource["GraphDefinition"] = "GraphDefinition";
+    TestScriptSetupActionAssertResource["Account"] = "Account";
+    TestScriptSetupActionAssertResource["Url"] = "url";
+    TestScriptSetupActionAssertResource["MedicinalProductIngredient"] = "MedicinalProductIngredient";
+    TestScriptSetupActionAssertResource["ProdCharacteristic"] = "ProdCharacteristic";
+    TestScriptSetupActionAssertResource["Meta"] = "Meta";
+    TestScriptSetupActionAssertResource["Quantity"] = "Quantity";
+    TestScriptSetupActionAssertResource["MeasureReport"] = "MeasureReport";
+    TestScriptSetupActionAssertResource["Distance"] = "Distance";
+    TestScriptSetupActionAssertResource["HumanName"] = "HumanName";
+    TestScriptSetupActionAssertResource["DeviceMetric"] = "DeviceMetric";
+    TestScriptSetupActionAssertResource["Duration"] = "Duration";
+    TestScriptSetupActionAssertResource["SubstanceAmount"] = "SubstanceAmount";
+    TestScriptSetupActionAssertResource["Goal"] = "Goal";
+    TestScriptSetupActionAssertResource["MedicationKnowledge"] = "MedicationKnowledge";
+    TestScriptSetupActionAssertResource["Integer"] = "integer";
+    TestScriptSetupActionAssertResource["String"] = "string";
+    TestScriptSetupActionAssertResource["ClaimResponse"] = "ClaimResponse";
+    TestScriptSetupActionAssertResource["DeviceDefinition"] = "DeviceDefinition";
+    TestScriptSetupActionAssertResource["Slot"] = "Slot";
+    TestScriptSetupActionAssertResource["ValueSet"] = "ValueSet";
+    TestScriptSetupActionAssertResource["MedicinalProductAuthorization"] = "MedicinalProductAuthorization";
+    TestScriptSetupActionAssertResource["StructureDefinition"] = "StructureDefinition";
+    TestScriptSetupActionAssertResource["Base64Binary"] = "base64Binary";
+    TestScriptSetupActionAssertResource["MedicinalProductContraindication"] = "MedicinalProductContraindication";
+    TestScriptSetupActionAssertResource["ElementDefinition"] = "ElementDefinition";
+    TestScriptSetupActionAssertResource["DeviceRequest"] = "DeviceRequest";
+    TestScriptSetupActionAssertResource["List"] = "List";
+    TestScriptSetupActionAssertResource["Questionnaire"] = "Questionnaire";
+    TestScriptSetupActionAssertResource["DomainResource"] = "DomainResource";
+    TestScriptSetupActionAssertResource["Endpoint"] = "Endpoint";
+    TestScriptSetupActionAssertResource["NamingSystem"] = "NamingSystem";
+    TestScriptSetupActionAssertResource["MedicinalProductPackaged"] = "MedicinalProductPackaged";
+    TestScriptSetupActionAssertResource["Basic"] = "Basic";
+    TestScriptSetupActionAssertResource["Money"] = "Money";
+    TestScriptSetupActionAssertResource["Binary"] = "Binary";
+    TestScriptSetupActionAssertResource["PlanDefinition"] = "PlanDefinition";
+    TestScriptSetupActionAssertResource["Subscription"] = "Subscription";
+    TestScriptSetupActionAssertResource["SampledData"] = "SampledData";
+    TestScriptSetupActionAssertResource["ProductShelfLife"] = "ProductShelfLife";
+    TestScriptSetupActionAssertResource["RelatedPerson"] = "RelatedPerson";
+    TestScriptSetupActionAssertResource["SubstanceSpecification"] = "SubstanceSpecification";
+    TestScriptSetupActionAssertResource["Ratio"] = "Ratio";
+    TestScriptSetupActionAssertResource["SubstanceNucleicAcid"] = "SubstanceNucleicAcid";
+    TestScriptSetupActionAssertResource["GuidanceResponse"] = "GuidanceResponse";
+    TestScriptSetupActionAssertResource["ClinicalImpression"] = "ClinicalImpression";
+    TestScriptSetupActionAssertResource["OrganizationAffiliation"] = "OrganizationAffiliation";
+    TestScriptSetupActionAssertResource["Resource"] = "Resource";
+    TestScriptSetupActionAssertResource["UnsignedInt"] = "unsignedInt";
+    TestScriptSetupActionAssertResource["Condition"] = "Condition";
+    TestScriptSetupActionAssertResource["Extension"] = "Extension";
+    TestScriptSetupActionAssertResource["CapabilityStatement"] = "CapabilityStatement";
+    TestScriptSetupActionAssertResource["HealthcareService"] = "HealthcareService";
+    TestScriptSetupActionAssertResource["SpecimenDefinition"] = "SpecimenDefinition";
+    TestScriptSetupActionAssertResource["ParameterDefinition"] = "ParameterDefinition";
+    TestScriptSetupActionAssertResource["RiskAssessment"] = "RiskAssessment";
+    TestScriptSetupActionAssertResource["Xhtml"] = "xhtml";
+    TestScriptSetupActionAssertResource["OperationDefinition"] = "OperationDefinition";
+    TestScriptSetupActionAssertResource["ActivityDefinition"] = "ActivityDefinition";
+    TestScriptSetupActionAssertResource["Schedule"] = "Schedule";
+    TestScriptSetupActionAssertResource["BiologicallyDerivedProduct"] = "BiologicallyDerivedProduct";
+    TestScriptSetupActionAssertResource["PositiveInt"] = "positiveInt";
+    TestScriptSetupActionAssertResource["Code"] = "code";
+    TestScriptSetupActionAssertResource["Group"] = "Group";
+    TestScriptSetupActionAssertResource["MedicinalProductPharmaceutical"] = "MedicinalProductPharmaceutical";
+    TestScriptSetupActionAssertResource["FamilyMemberHistory"] = "FamilyMemberHistory";
+    TestScriptSetupActionAssertResource["ServiceRequest"] = "ServiceRequest";
+    TestScriptSetupActionAssertResource["DetectedIssue"] = "DetectedIssue";
+    TestScriptSetupActionAssertResource["Device"] = "Device";
+    TestScriptSetupActionAssertResource["Oid"] = "oid";
+    TestScriptSetupActionAssertResource["RequestGroup"] = "RequestGroup";
+    TestScriptSetupActionAssertResource["TestScript"] = "TestScript";
+    TestScriptSetupActionAssertResource["RiskEvidenceSynthesis"] = "RiskEvidenceSynthesis";
+    TestScriptSetupActionAssertResource["SupplyRequest"] = "SupplyRequest";
+    TestScriptSetupActionAssertResource["Element"] = "Element";
+    TestScriptSetupActionAssertResource["Reference"] = "Reference";
+    TestScriptSetupActionAssertResource["Task"] = "Task";
+    TestScriptSetupActionAssertResource["Identifier"] = "Identifier";
+    TestScriptSetupActionAssertResource["CommunicationRequest"] = "CommunicationRequest";
+    TestScriptSetupActionAssertResource["EnrollmentRequest"] = "EnrollmentRequest";
+    TestScriptSetupActionAssertResource["ChargeItemDefinition"] = "ChargeItemDefinition";
+    TestScriptSetupActionAssertResource["Substance"] = "Substance";
+    TestScriptSetupActionAssertResource["Id"] = "id";
+    TestScriptSetupActionAssertResource["Provenance"] = "Provenance";
+    TestScriptSetupActionAssertResource["Time"] = "time";
+    TestScriptSetupActionAssertResource["Consent"] = "Consent";
+    TestScriptSetupActionAssertResource["BackboneElement"] = "BackboneElement";
+    TestScriptSetupActionAssertResource["CarePlan"] = "CarePlan";
+    TestScriptSetupActionAssertResource["Narrative"] = "Narrative";
+    TestScriptSetupActionAssertResource["MoneyQuantity"] = "MoneyQuantity";
+    TestScriptSetupActionAssertResource["TestReport"] = "TestReport";
+    TestScriptSetupActionAssertResource["Observation"] = "Observation";
+    TestScriptSetupActionAssertResource["DateTime"] = "dateTime";
+    TestScriptSetupActionAssertResource["Boolean"] = "boolean";
+    TestScriptSetupActionAssertResource["DocumentManifest"] = "DocumentManifest";
+    TestScriptSetupActionAssertResource["Contributor"] = "Contributor";
+})(TestScriptSetupActionAssertResource = exports.TestScriptSetupActionAssertResource || (exports.TestScriptSetupActionAssertResource = {}));
+/** Mime type to accept in the payload of the response, with charset etc. */
+var TestScriptSetupActionOperationAccept;
+(function (TestScriptSetupActionOperationAccept) {
+    TestScriptSetupActionOperationAccept["Application/hl7Cda+xml"] = "application/hl7-cda+xml";
+    TestScriptSetupActionOperationAccept["Application/sparqlResults+xml"] = "application/sparql-results+xml";
+    TestScriptSetupActionOperationAccept["Application/sql"] = "application/sql";
+    TestScriptSetupActionOperationAccept["Application/xquery"] = "application/xquery";
+})(TestScriptSetupActionOperationAccept = exports.TestScriptSetupActionOperationAccept || (exports.TestScriptSetupActionOperationAccept = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Timing.d.ts b/vendor/r4/types/hl7-fhir-r4-core/Timing.d.ts
index 469ffb9..b98d15f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Timing.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/Timing.d.ts
@@ -22,6 +22,26 @@ export interface Timing extends BackboneElement {
     /** BID | TID | QID | AM | PM | QD | QOD | + */
     code?: CodeableConcept;
 }
+/** s | min | h | d | wk | mo | a - unit of time (UCUM) */
+export declare enum TimingPeriodUnit {
+    D = "d",
+    Min = "min",
+    S = "s",
+    Mo = "mo",
+    Wk = "wk",
+    A = "a",
+    H = "h"
+}
+/** s | min | h | d | wk | mo | a - unit of time (UCUM) */
+export declare enum TimingDurationUnit {
+    D = "d",
+    Min = "min",
+    S = "s",
+    Mo = "mo",
+    Wk = "wk",
+    A = "a",
+    H = "h"
+}
 /** When the event is to occur */
 export interface TimingRepeat extends Element {
     _period?: Element;
@@ -41,7 +61,7 @@ export interface TimingRepeat extends Element {
     _duration?: Element;
     _frequency?: Element;
     /** s | min | h | d | wk | mo | a - unit of time (UCUM) */
-    periodUnit?: code;
+    periodUnit?: `${TimingPeriodUnit}`;
     _timeOfDay?: Array<Element>;
     _frequencyMax?: Element;
     /** Event occurs frequency times per period */
@@ -52,7 +72,7 @@ export interface TimingRepeat extends Element {
     duration?: decimal;
     boundsDuration?: Duration;
     /** s | min | h | d | wk | mo | a - unit of time (UCUM) */
-    durationUnit?: code;
+    durationUnit?: `${TimingDurationUnit}`;
     /** mon | tue | wed | thu | fri | sat | sun */
     dayOfWeek?: Array<code>;
     /** Number of times to repeat */
diff --git a/vendor/r4/types/hl7-fhir-r4-core/Timing.js b/vendor/r4/types/hl7-fhir-r4-core/Timing.js
index c8ad2e5..2ec947f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/Timing.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/Timing.js
@@ -1,2 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimingDurationUnit = exports.TimingPeriodUnit = void 0;
+/** s | min | h | d | wk | mo | a - unit of time (UCUM) */
+var TimingPeriodUnit;
+(function (TimingPeriodUnit) {
+    TimingPeriodUnit["D"] = "d";
+    TimingPeriodUnit["Min"] = "min";
+    TimingPeriodUnit["S"] = "s";
+    TimingPeriodUnit["Mo"] = "mo";
+    TimingPeriodUnit["Wk"] = "wk";
+    TimingPeriodUnit["A"] = "a";
+    TimingPeriodUnit["H"] = "h";
+})(TimingPeriodUnit = exports.TimingPeriodUnit || (exports.TimingPeriodUnit = {}));
+/** s | min | h | d | wk | mo | a - unit of time (UCUM) */
+var TimingDurationUnit;
+(function (TimingDurationUnit) {
+    TimingDurationUnit["D"] = "d";
+    TimingDurationUnit["Min"] = "min";
+    TimingDurationUnit["S"] = "s";
+    TimingDurationUnit["Mo"] = "mo";
+    TimingDurationUnit["Wk"] = "wk";
+    TimingDurationUnit["A"] = "a";
+    TimingDurationUnit["H"] = "h";
+})(TimingDurationUnit = exports.TimingDurationUnit || (exports.TimingDurationUnit = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/TriggerDefinition.d.ts b/vendor/r4/types/hl7-fhir-r4-core/TriggerDefinition.d.ts
index b90848f..3e922cb 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/TriggerDefinition.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/TriggerDefinition.d.ts
@@ -7,15 +7,14 @@ import { Timing } from "./Timing";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 /** Base StructureDefinition for TriggerDefinition Type: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element. */
 export interface TriggerDefinition extends Element {
-    timingReference?: Reference<"Schedule">;
+    timingReference?: Reference<'Schedule'>;
     /** Name or URI that identifies the event */
     name?: string;
     _type?: Element;
     /** named-event | periodic | data-changed | data-added | data-modified | data-removed | data-accessed | data-access-ended */
-    type: code;
+    type: `${TriggerDefinitionType}`;
     timingDateTime?: dateTime;
     timingTiming?: Timing;
     /** Whether the event triggers (boolean expression) */
@@ -27,3 +26,14 @@ export interface TriggerDefinition extends Element {
     /** Triggering data of the event (multiple = 'and') */
     data?: Array<DataRequirement>;
 }
+/** named-event | periodic | data-changed | data-added | data-modified | data-removed | data-accessed | data-access-ended */
+export declare enum TriggerDefinitionType {
+    DataAccessEnded = "data-access-ended",
+    DataAccessed = "data-accessed",
+    DataAdded = "data-added",
+    DataChanged = "data-changed",
+    DataModified = "data-modified",
+    DataRemoved = "data-removed",
+    NamedEvent = "named-event",
+    Periodic = "periodic"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/TriggerDefinition.js b/vendor/r4/types/hl7-fhir-r4-core/TriggerDefinition.js
index c8ad2e5..80f1d52 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/TriggerDefinition.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/TriggerDefinition.js
@@ -1,2 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggerDefinitionType = void 0;
+/** named-event | periodic | data-changed | data-added | data-modified | data-removed | data-accessed | data-access-ended */
+var TriggerDefinitionType;
+(function (TriggerDefinitionType) {
+    TriggerDefinitionType["DataAccessEnded"] = "data-access-ended";
+    TriggerDefinitionType["DataAccessed"] = "data-accessed";
+    TriggerDefinitionType["DataAdded"] = "data-added";
+    TriggerDefinitionType["DataChanged"] = "data-changed";
+    TriggerDefinitionType["DataModified"] = "data-modified";
+    TriggerDefinitionType["DataRemoved"] = "data-removed";
+    TriggerDefinitionType["NamedEvent"] = "named-event";
+    TriggerDefinitionType["Periodic"] = "periodic";
+})(TriggerDefinitionType = exports.TriggerDefinitionType || (exports.TriggerDefinitionType = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/UsageContext.d.ts b/vendor/r4/types/hl7-fhir-r4-core/UsageContext.d.ts
index 0405071..3c89255 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/UsageContext.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/UsageContext.d.ts
@@ -13,5 +13,5 @@ export interface UsageContext extends Element {
     valueCodeableConcept: CodeableConcept;
     valueQuantity: Quantity;
     valueRange: Range;
-    valueReference: Reference<"InsurancePlan" | "HealthcareService" | "Organization" | "ResearchStudy" | "Location" | "PlanDefinition" | "Group">;
+    valueReference: Reference<'InsurancePlan' | 'HealthcareService' | 'Organization' | 'ResearchStudy' | 'Location' | 'PlanDefinition' | 'Group'>;
 }
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ValueSet.d.ts b/vendor/r4/types/hl7-fhir-r4-core/ValueSet.d.ts
index 0abd174..e507307 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ValueSet.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/ValueSet.d.ts
@@ -18,6 +18,7 @@ import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html). */
 export interface ValueSet extends DomainResource {
+    resourceType: 'ValueSet';
     /** Natural language description of the value set */
     description?: markdown;
     /** Content logical definition of the value set (CLD) */
@@ -49,7 +50,7 @@ export interface ValueSet extends DomainResource {
     _description?: Element;
     _purpose?: Element;
     /** draft | active | retired | unknown */
-    status: code;
+    status: `${ValueSetStatus}`;
     _immutable?: Element;
     _name?: Element;
     /** Canonical identifier for this value set, represented as a URI (globally unique) */
@@ -67,6 +68,43 @@ export interface ValueSet extends DomainResource {
     contact?: Array<ContactDetail>;
     _url?: Element;
 }
+/** = | is-a | descendent-of | is-not-a | regex | in | not-in | generalizes | exists */
+export declare enum ValueSetComposeIncludeOp {
+    Exists = "exists",
+    In = "in",
+    IsNotA = "is-not-a",
+    "=" = "=",
+    Generalizes = "generalizes",
+    DescendentOf = "descendent-of",
+    Regex = "regex",
+    IsA = "is-a",
+    NotIn = "not-in"
+}
+/** draft | active | retired | unknown */
+export declare enum ValueSetStatus {
+    Active = "active",
+    Draft = "draft",
+    Retired = "retired",
+    Unknown = "unknown"
+}
+/** Used when the value set is "expanded" */
+export interface ValueSetExpansion extends BackboneElement {
+    contains?: Array<ValueSetExpansionContains>;
+    _timestamp?: Element;
+    _offset?: Element;
+    /** Offset at which this resource starts */
+    offset?: integer;
+    /** Total number of codes in the expansion */
+    total?: integer;
+    _identifier?: Element;
+    /** Identifies the value set expansion (business identifier) */
+    identifier?: uri;
+    /** Time ValueSet expansion happened */
+    timestamp: dateTime;
+    /** Parameter that controlled the expansion process */
+    parameter?: Array<ValueSetParameter>;
+    _total?: Element;
+}
 /** Content logical definition of the value set (CLD) */
 export interface ValueSetCompose extends BackboneElement {
     /** Fixed date for references with no specified version (transitive) */
@@ -79,6 +117,28 @@ export interface ValueSetCompose extends BackboneElement {
     /** Explicitly exclude codes from a code system or other value sets */
     exclude?: Array<ValueSetComposeInclude>;
 }
+/** Select codes/concepts by their properties (including relationships) */
+export interface ValueSetComposeIncludeFilter extends BackboneElement {
+    /** A property/filter defined by the code system */
+    property: code;
+    _property?: Element;
+    /** = | is-a | descendent-of | is-not-a | regex | in | not-in | generalizes | exists */
+    op: `${ValueSetComposeIncludeOp}`;
+    _op?: Element;
+    /** Code from the system, or regex criteria, or boolean value for exists */
+    value: string;
+    _value?: Element;
+}
+/** A concept defined in the system */
+export interface ValueSetComposeIncludeConcept extends BackboneElement {
+    /** Code or expression from system */
+    code: code;
+    _code?: Element;
+    /** Text to display for this code for this value set in this valueset */
+    display?: string;
+    _display?: Element;
+    designation?: Array<ValueSetComposeIncludeConceptDesignation>;
+}
 /** Parameter that controlled the expansion process */
 export interface ValueSetParameter extends BackboneElement {
     _valueUri?: Element;
@@ -99,45 +159,30 @@ export interface ValueSetParameter extends BackboneElement {
     _valueCode?: Element;
     _valueInteger?: Element;
 }
-/** Used when the value set is "expanded" */
-export interface ValueSetExpansion extends BackboneElement {
-    contains?: Array<ValueSetExpansionContains>;
-    _timestamp?: Element;
-    _offset?: Element;
-    /** Offset at which this resource starts */
-    offset?: integer;
-    /** Total number of codes in the expansion */
-    total?: integer;
-    _identifier?: Element;
-    /** Identifies the value set expansion (business identifier) */
-    identifier?: uri;
-    /** Time ValueSet expansion happened */
-    timestamp: dateTime;
-    /** Parameter that controlled the expansion process */
-    parameter?: Array<ValueSetParameter>;
-    _total?: Element;
-}
-/** A concept defined in the system */
-export interface ValueSetComposeIncludeConcept extends BackboneElement {
-    /** Code or expression from system */
-    code: code;
+/** Codes in the value set */
+export interface ValueSetExpansionContains extends BackboneElement {
+    /** If concept is inactive in the code system */
+    inactive?: boolean;
     _code?: Element;
-    /** Text to display for this code for this value set in this valueset */
+    /** System value for the code */
+    system?: uri;
+    /** Codes contained under this entry */
+    contains?: Array<ValueSetExpansionContains>;
+    /** If user cannot select this entry */
+    abstract?: boolean;
+    _abstract?: Element;
+    /** Code - if blank, this is not a selectable code */
+    code?: code;
+    /** User display for the concept */
     display?: string;
-    _display?: Element;
+    /** Additional representations for this item */
     designation?: Array<ValueSetComposeIncludeConceptDesignation>;
-}
-/** Select codes/concepts by their properties (including relationships) */
-export interface ValueSetComposeIncludeFilter extends BackboneElement {
-    /** A property/filter defined by the code system */
-    property: code;
-    _property?: Element;
-    /** = | is-a | descendent-of | is-not-a | regex | in | not-in | generalizes | exists */
-    op: code;
-    _op?: Element;
-    /** Code from the system, or regex criteria, or boolean value for exists */
-    value: string;
-    _value?: Element;
+    _system?: Element;
+    /** Version in which this code/display is defined */
+    version?: string;
+    _version?: Element;
+    _display?: Element;
+    _inactive?: Element;
 }
 /** Include one or more codes from a code system or other value set(s) */
 export interface ValueSetComposeInclude extends BackboneElement {
@@ -166,28 +211,3 @@ export interface ValueSetComposeIncludeConceptDesignation extends BackboneElemen
     value: string;
     _value?: Element;
 }
-/** Codes in the value set */
-export interface ValueSetExpansionContains extends BackboneElement {
-    /** If concept is inactive in the code system */
-    inactive?: boolean;
-    _code?: Element;
-    /** System value for the code */
-    system?: uri;
-    /** Codes contained under this entry */
-    contains?: Array<ValueSetExpansionContains>;
-    /** If user cannot select this entry */
-    abstract?: boolean;
-    _abstract?: Element;
-    /** Code - if blank, this is not a selectable code */
-    code?: code;
-    /** User display for the concept */
-    display?: string;
-    /** Additional representations for this item */
-    designation?: Array<ValueSetComposeIncludeConceptDesignation>;
-    _system?: Element;
-    /** Version in which this code/display is defined */
-    version?: string;
-    _version?: Element;
-    _display?: Element;
-    _inactive?: Element;
-}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/ValueSet.js b/vendor/r4/types/hl7-fhir-r4-core/ValueSet.js
index c8ad2e5..b7fb132 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/ValueSet.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/ValueSet.js
@@ -1,2 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueSetStatus = exports.ValueSetComposeIncludeOp = void 0;
+/** = | is-a | descendent-of | is-not-a | regex | in | not-in | generalizes | exists */
+var ValueSetComposeIncludeOp;
+(function (ValueSetComposeIncludeOp) {
+    ValueSetComposeIncludeOp["Exists"] = "exists";
+    ValueSetComposeIncludeOp["In"] = "in";
+    ValueSetComposeIncludeOp["IsNotA"] = "is-not-a";
+    ValueSetComposeIncludeOp["="] = "=";
+    ValueSetComposeIncludeOp["Generalizes"] = "generalizes";
+    ValueSetComposeIncludeOp["DescendentOf"] = "descendent-of";
+    ValueSetComposeIncludeOp["Regex"] = "regex";
+    ValueSetComposeIncludeOp["IsA"] = "is-a";
+    ValueSetComposeIncludeOp["NotIn"] = "not-in";
+})(ValueSetComposeIncludeOp = exports.ValueSetComposeIncludeOp || (exports.ValueSetComposeIncludeOp = {}));
+/** draft | active | retired | unknown */
+var ValueSetStatus;
+(function (ValueSetStatus) {
+    ValueSetStatus["Active"] = "active";
+    ValueSetStatus["Draft"] = "draft";
+    ValueSetStatus["Retired"] = "retired";
+    ValueSetStatus["Unknown"] = "unknown";
+})(ValueSetStatus = exports.ValueSetStatus || (exports.ValueSetStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/VerificationResult.d.ts b/vendor/r4/types/hl7-fhir-r4-core/VerificationResult.d.ts
index d9d42f8..6631ae1 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/VerificationResult.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/VerificationResult.d.ts
@@ -8,10 +8,10 @@ import { DomainResource } from "./DomainResource";
 import { date } from "./date";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { BackboneElement } from "./BackboneElement";
 /** Describes validation requirements, source(s), status and dates for one or more elements. */
 export interface VerificationResult extends DomainResource {
+    resourceType: 'VerificationResult';
     /** fatal | warn | rec-only | none */
     failureAction?: CodeableConcept;
     /** nothing | primary | multiple */
@@ -33,7 +33,7 @@ export interface VerificationResult extends DomainResource {
     /** Information about the entity attesting to information */
     attestation?: VerificationResultAttestation;
     /** attested | validated | in-process | req-revalid | val-fail | reval-fail */
-    status: code;
+    status: `${VerificationResultStatus}`;
     /** The primary process by which the target is validated (edit check; value set; primary source; multiple sources; standalone; in context) */
     validationProcess?: Array<CodeableConcept>;
     /** When the validation status was updated */
@@ -49,7 +49,7 @@ export interface VerificationResult extends DomainResource {
 /** Information about the entity validating information */
 export interface VerificationResultValidator extends BackboneElement {
     /** Reference to the organization validating information */
-    organization: Reference<"Organization">;
+    organization: Reference<'Organization'>;
     /** A digital identity certificate associated with the validator */
     identityCertificate?: string;
     _identityCertificate?: Element;
@@ -59,7 +59,7 @@ export interface VerificationResultValidator extends BackboneElement {
 /** Information about the primary source(s) involved in validation */
 export interface VerificationResultPrimarySource extends BackboneElement {
     /** Reference to the primary source */
-    who?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    who?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** Type of primary source (License Board; Primary Education; Continuing Education; Postal Service; Relationship owner; Registration Authority; legal source; issuing source; authoritative source) */
     type?: Array<CodeableConcept>;
     /** Method for exchanging information with the primary source */
@@ -77,7 +77,7 @@ export interface VerificationResultPrimarySource extends BackboneElement {
 /** Information about the entity attesting to information */
 export interface VerificationResultAttestation extends BackboneElement {
     /** The individual or organization attesting to information */
-    who?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    who?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     /** The date the information was attested to */
     date?: date;
     /** A digital identity certificate associated with the proxy entity submitting attested information on behalf of the attestation source */
@@ -85,7 +85,7 @@ export interface VerificationResultAttestation extends BackboneElement {
     /** Attester signature */
     sourceSignature?: Signature;
     /** When the who is asserting on behalf of another (organization or individual) */
-    onBehalfOf?: Reference<"PractitionerRole" | "Organization" | "Practitioner">;
+    onBehalfOf?: Reference<'PractitionerRole' | 'Organization' | 'Practitioner'>;
     _proxyIdentityCertificate?: Element;
     _date?: Element;
     /** Proxy signature */
@@ -96,3 +96,12 @@ export interface VerificationResultAttestation extends BackboneElement {
     /** A digital identity certificate associated with the attestation source */
     sourceIdentityCertificate?: string;
 }
+/** attested | validated | in-process | req-revalid | val-fail | reval-fail */
+export declare enum VerificationResultStatus {
+    Attested = "attested",
+    InProcess = "in-process",
+    ReqRevalid = "req-revalid",
+    RevalFail = "reval-fail",
+    ValFail = "val-fail",
+    Validated = "validated"
+}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/VerificationResult.js b/vendor/r4/types/hl7-fhir-r4-core/VerificationResult.js
index c8ad2e5..e016d5f 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/VerificationResult.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/VerificationResult.js
@@ -1,2 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationResultStatus = void 0;
+/** attested | validated | in-process | req-revalid | val-fail | reval-fail */
+var VerificationResultStatus;
+(function (VerificationResultStatus) {
+    VerificationResultStatus["Attested"] = "attested";
+    VerificationResultStatus["InProcess"] = "in-process";
+    VerificationResultStatus["ReqRevalid"] = "req-revalid";
+    VerificationResultStatus["RevalFail"] = "reval-fail";
+    VerificationResultStatus["ValFail"] = "val-fail";
+    VerificationResultStatus["Validated"] = "validated";
+})(VerificationResultStatus = exports.VerificationResultStatus || (exports.VerificationResultStatus = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/VisionPrescription.d.ts b/vendor/r4/types/hl7-fhir-r4-core/VisionPrescription.d.ts
index e46798e..00c13eb 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/VisionPrescription.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/VisionPrescription.d.ts
@@ -8,39 +8,58 @@ import { integer } from "./integer";
 import { DomainResource } from "./DomainResource";
 import { Element } from "./Element";
 import { Reference } from "./Reference";
-import { code } from "./code";
 import { Identifier } from "./Identifier";
 import { BackboneElement } from "./BackboneElement";
 import { decimal } from "./decimal";
 /** An authorization for the provision of glasses and/or contact lenses to a patient. */
 export interface VisionPrescription extends DomainResource {
+    resourceType: 'VisionPrescription';
     _created?: Element;
     /** Who prescription is for */
-    patient: Reference<"Patient">;
+    patient: Reference<'Patient'>;
     /** Created during encounter / admission / stay */
-    encounter?: Reference<"Encounter">;
+    encounter?: Reference<'Encounter'>;
     _status?: Element;
     /** Response creation date */
     created: dateTime;
     /** active | cancelled | draft | entered-in-error */
-    status: code;
+    status: `${VisionPrescriptionStatus}`;
     /** Business Identifier for vision prescription */
     identifier?: Array<Identifier>;
     /** Who authorized the vision prescription */
-    prescriber: Reference<"PractitionerRole" | "Practitioner">;
+    prescriber: Reference<'PractitionerRole' | 'Practitioner'>;
     /** When prescription was authorized */
     dateWritten: dateTime;
     _dateWritten?: Element;
     /** Vision lens authorization */
     lensSpecification: Array<VisionPrescriptionLensSpecification>;
 }
+/** active | cancelled | draft | entered-in-error */
+export declare enum VisionPrescriptionStatus {
+    Active = "active",
+    Cancelled = "cancelled",
+    Draft = "draft",
+    EnteredInError = "entered-in-error"
+}
+/** right | left */
+export declare enum VisionPrescriptionEye {
+    Left = "left",
+    Right = "right"
+}
+/** up | down | in | out */
+export declare enum VisionPrescriptionBase {
+    Down = "down",
+    In = "in",
+    Out = "out",
+    Up = "up"
+}
 /** Eye alignment compensation */
 export interface VisionPrescriptionPrism extends BackboneElement {
     /** Amount of adjustment */
     amount: decimal;
     _amount?: Element;
     /** up | down | in | out */
-    base: code;
+    base: `${VisionPrescriptionBase}`;
     _base?: Element;
 }
 /** Vision lens authorization */
@@ -52,7 +71,7 @@ export interface VisionPrescriptionLensSpecification extends BackboneElement {
     /** Color required */
     color?: string;
     /** right | left */
-    eye: code;
+    eye: `${VisionPrescriptionEye}`;
     _add?: Element;
     /** Contact lens diameter */
     diameter?: decimal;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/VisionPrescription.js b/vendor/r4/types/hl7-fhir-r4-core/VisionPrescription.js
index c8ad2e5..fea92e9 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/VisionPrescription.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/VisionPrescription.js
@@ -1,2 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisionPrescriptionBase = exports.VisionPrescriptionEye = exports.VisionPrescriptionStatus = void 0;
+/** active | cancelled | draft | entered-in-error */
+var VisionPrescriptionStatus;
+(function (VisionPrescriptionStatus) {
+    VisionPrescriptionStatus["Active"] = "active";
+    VisionPrescriptionStatus["Cancelled"] = "cancelled";
+    VisionPrescriptionStatus["Draft"] = "draft";
+    VisionPrescriptionStatus["EnteredInError"] = "entered-in-error";
+})(VisionPrescriptionStatus = exports.VisionPrescriptionStatus || (exports.VisionPrescriptionStatus = {}));
+/** right | left */
+var VisionPrescriptionEye;
+(function (VisionPrescriptionEye) {
+    VisionPrescriptionEye["Left"] = "left";
+    VisionPrescriptionEye["Right"] = "right";
+})(VisionPrescriptionEye = exports.VisionPrescriptionEye || (exports.VisionPrescriptionEye = {}));
+/** up | down | in | out */
+var VisionPrescriptionBase;
+(function (VisionPrescriptionBase) {
+    VisionPrescriptionBase["Down"] = "down";
+    VisionPrescriptionBase["In"] = "in";
+    VisionPrescriptionBase["Out"] = "out";
+    VisionPrescriptionBase["Up"] = "up";
+})(VisionPrescriptionBase = exports.VisionPrescriptionBase || (exports.VisionPrescriptionBase = {}));
diff --git a/vendor/r4/types/hl7-fhir-r4-core/base64Binary.d.ts b/vendor/r4/types/hl7-fhir-r4-core/base64Binary.d.ts
index b605f92..7ce8a29 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/base64Binary.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/base64Binary.d.ts
@@ -1,6 +1,6 @@
 /** GENERATED BY zen-cli
 DON'T MODIFY MANUALLY */
 /** Base StructureDefinition for base64Binary Type: A stream of bytes
- * @pattern ^(\s*([0-9a-zA-Z\+\=\/]){4})++\s*$
+* @pattern ^(\s*([0-9a-zA-Z\+\=\/]){4})++\s*$
  */
 export type base64Binary = string;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/code.d.ts b/vendor/r4/types/hl7-fhir-r4-core/code.d.ts
index 4e729d2..01ba9d7 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/code.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/code.d.ts
@@ -1,6 +1,6 @@
 /** GENERATED BY zen-cli
 DON'T MODIFY MANUALLY */
 /** Base StructureDefinition for code type: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
- * @pattern ^[^\s]+(\s[^\s]+)*$
+* @pattern ^[^\s]+(\s[^\s]+)*$
  */
 export type code = string;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/date.d.ts b/vendor/r4/types/hl7-fhir-r4-core/date.d.ts
index 93ade8b..f58e578 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/date.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/date.d.ts
@@ -1,6 +1,6 @@
 /** GENERATED BY zen-cli
 DON'T MODIFY MANUALLY */
 /** Base StructureDefinition for date Type: A date or partial date (e.g. just year or year + month). There is no time zone. The format is a union of the schema types gYear, gYearMonth and date.  Dates SHALL be valid dates.
- * @pattern ^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1]))?)?$
+* @pattern ^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1]))?)?$
  */
 export type date = string;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/dateTime.d.ts b/vendor/r4/types/hl7-fhir-r4-core/dateTime.d.ts
index c757b69..210b8e4 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/dateTime.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/dateTime.d.ts
@@ -1,6 +1,6 @@
 /** GENERATED BY zen-cli
 DON'T MODIFY MANUALLY */
 /** Base StructureDefinition for dateTime Type: A date, date-time or partial date (e.g. just year or year + month).  If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored.                 Dates SHALL be valid dates.
- * @pattern ^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$
+* @pattern ^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$
  */
 export type dateTime = string;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/id.d.ts b/vendor/r4/types/hl7-fhir-r4-core/id.d.ts
index e6bdbbb..3cd5047 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/id.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/id.d.ts
@@ -1,6 +1,6 @@
 /** GENERATED BY zen-cli
 DON'T MODIFY MANUALLY */
 /** Base StructureDefinition for id type: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters.  (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.)  Ids are case-insensitive.
- * @pattern ^[A-Za-z0-9\-\.]{1,64}$
+* @pattern ^[A-Za-z0-9\-\.]*$
  */
 export type id = string;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/index.d.ts b/vendor/r4/types/hl7-fhir-r4-core/index.d.ts
deleted file mode 100644
index 9fe65cc..0000000
--- a/vendor/r4/types/hl7-fhir-r4-core/index.d.ts
+++ /dev/null
@@ -1,2231 +0,0 @@
-/** GENERATED BY zen-cli
-DON'T MODIFY MANUALLY */
-export * from "./ImmunizationEvaluation";
-export * from "./Appointment";
-export * from "./StructureMap";
-export * from "./Address";
-export * from "./CareTeam";
-export * from "./UsageContext";
-export * from "./Linkage";
-export * from "./Annotation";
-export * from "./Age";
-export * from "./Attachment";
-export * from "./positiveInt";
-export * from "./unsignedInt";
-export * from "./Communication";
-export * from "./MedicationDispense";
-export * from "./ImagingStudy";
-export * from "./ChargeItem";
-export * from "./Period";
-export * from "./AdverseEvent";
-export * from "./url";
-export * from "./ContactDetail";
-export * from "./DataRequirement";
-export * from "./Media";
-export * from "./CodeableConcept";
-export * from "./SubstancePolymer";
-export * from "./QuestionnaireResponse";
-export * from "./Coverage";
-export * from "./Procedure";
-export * from "./AuditEvent";
-export * from "./PaymentReconciliation";
-export * from "./MedicinalProductManufactured";
-export * from "./CompartmentDefinition";
-export * from "./Organization";
-export * from "./ExplanationOfBenefit";
-export * from "./Composition";
-export * from "./SimpleQuantity";
-export * from "./CoverageEligibilityResponse";
-export * from "./DocumentReference";
-export * from "./EventDefinition";
-export * from "./SubstanceProtein";
-export * from "./TerminologyCapabilities";
-export * from "./Encounter";
-export * from "./ImplementationGuide";
-export * from "./EvidenceVariable";
-export * from "./ObservationDefinition";
-export * from "./DiagnosticReport";
-export * from "./ExampleScenario";
-export * from "./ResearchDefinition";
-export * from "./Parameters";
-export * from "./SearchParameter";
-export * from "./MedicinalProductInteraction";
-export * from "./CodeSystem";
-export * from "./MessageDefinition";
-export * from "./NutritionOrder";
-export * from "./xhtml";
-export * from "./VerificationResult";
-export * from "./MedicationAdministration";
-export * from "./CatalogEntry";
-export * from "./Flag";
-export * from "./DeviceUseStatement";
-export * from "./TriggerDefinition";
-export * from "./uri";
-export * from "./Contract";
-export * from "./Invoice";
-export * from "./MarketingStatus";
-export * from "./Count";
-export * from "./PaymentNotice";
-export * from "./Location";
-export * from "./Claim";
-export * from "./Specimen";
-export * from "./MedicationStatement";
-export * from "./EnrollmentResponse";
-export * from "./Evidence";
-export * from "./Bundle";
-export * from "./ResearchElementDefinition";
-export * from "./Expression";
-export * from "./Coding";
-export * from "./BodyStructure";
-export * from "./id";
-export * from "./MedicinalProduct";
-export * from "./dateTime";
-export * from "./ResearchStudy";
-export * from "./Dosage";
-export * from "./AppointmentResponse";
-export * from "./MedicinalProductIndication";
-export * from "./Measure";
-export * from "./Person";
-export * from "./InsurancePlan";
-export * from "./Patient";
-export * from "./EffectEvidenceSynthesis";
-export * from "./ResearchSubject";
-export * from "./Medication";
-export * from "./Range";
-export * from "./ConceptMap";
-export * from "./CoverageEligibilityRequest";
-export * from "./Population";
-export * from "./SubstanceSourceMaterial";
-export * from "./VisionPrescription";
-export * from "./oid";
-export * from "./MolecularSequence";
-export * from "./MedicinalProductUndesirableEffect";
-export * from "./OperationOutcome";
-export * from "./MessageHeader";
-export * from "./ContactPoint";
-export * from "./uuid";
-export * from "./Signature";
-export * from "./AllergyIntolerance";
-export * from "./SubstanceReferenceInformation";
-export * from "./SupplyDelivery";
-export * from "./EpisodeOfCare";
-export * from "./PractitionerRole";
-export * from "./Library";
-export * from "./Practitioner";
-export * from "./MedicationRequest";
-export * from "./ImmunizationRecommendation";
-export * from "./RelatedArtifact";
-export * from "./Timing";
-export * from "./Immunization";
-export * from "./GraphDefinition";
-export * from "./Account";
-export * from "./MedicinalProductIngredient";
-export * from "./ProdCharacteristic";
-export * from "./Meta";
-export * from "./Quantity";
-export * from "./MeasureReport";
-export * from "./Distance";
-export * from "./canonical";
-export * from "./HumanName";
-export * from "./DeviceMetric";
-export * from "./Duration";
-export * from "./SubstanceAmount";
-export * from "./Goal";
-export * from "./time";
-export * from "./MedicationKnowledge";
-export * from "./ClaimResponse";
-export * from "./DeviceDefinition";
-export * from "./Slot";
-export * from "./ValueSet";
-export * from "./MedicinalProductAuthorization";
-export * from "./StructureDefinition";
-export * from "./integer";
-export * from "./MedicinalProductContraindication";
-export * from "./ElementDefinition";
-export * from "./DeviceRequest";
-export * from "./List";
-export * from "./Questionnaire";
-export * from "./DomainResource";
-export * from "./Endpoint";
-export * from "./NamingSystem";
-export * from "./MedicinalProductPackaged";
-export * from "./Basic";
-export * from "./Money";
-export * from "./Binary";
-export * from "./PlanDefinition";
-export * from "./Subscription";
-export * from "./SampledData";
-export * from "./ProductShelfLife";
-export * from "./RelatedPerson";
-export * from "./SubstanceSpecification";
-export * from "./date";
-export * from "./Ratio";
-export * from "./markdown";
-export * from "./SubstanceNucleicAcid";
-export * from "./GuidanceResponse";
-export * from "./ClinicalImpression";
-export * from "./OrganizationAffiliation";
-export * from "./Resource";
-export * from "./Condition";
-export * from "./Extension";
-export * from "./CapabilityStatement";
-export * from "./HealthcareService";
-export * from "./SpecimenDefinition";
-export * from "./ParameterDefinition";
-export * from "./RiskAssessment";
-export * from "./OperationDefinition";
-export * from "./ActivityDefinition";
-export * from "./Schedule";
-export * from "./BiologicallyDerivedProduct";
-export * from "./Group";
-export * from "./MedicinalProductPharmaceutical";
-export * from "./base64Binary";
-export * from "./FamilyMemberHistory";
-export * from "./ServiceRequest";
-export * from "./DetectedIssue";
-export * from "./instant";
-export * from "./Device";
-export * from "./RequestGroup";
-export * from "./TestScript";
-export * from "./RiskEvidenceSynthesis";
-export * from "./SupplyRequest";
-export * from "./Element";
-export * from "./Reference";
-export * from "./code";
-export * from "./Task";
-export * from "./Identifier";
-export * from "./CommunicationRequest";
-export * from "./EnrollmentRequest";
-export * from "./ChargeItemDefinition";
-export * from "./Substance";
-export * from "./Provenance";
-export * from "./Consent";
-export * from "./BackboneElement";
-export * from "./CarePlan";
-export * from "./Narrative";
-export * from "./decimal";
-export * from "./TestReport";
-export * from "./Observation";
-export * from "./DocumentManifest";
-export * from "./Contributor";
-import { ImmunizationEvaluation } from "./ImmunizationEvaluation";
-import { Appointment } from "./Appointment";
-import { StructureMap } from "./StructureMap";
-import { Address } from "./Address";
-import { CareTeam } from "./CareTeam";
-import { UsageContext } from "./UsageContext";
-import { Linkage } from "./Linkage";
-import { Annotation } from "./Annotation";
-import { Age } from "./Age";
-import { Attachment } from "./Attachment";
-import { positiveInt } from "./positiveInt";
-import { unsignedInt } from "./unsignedInt";
-import { Communication } from "./Communication";
-import { MedicationDispense } from "./MedicationDispense";
-import { ImagingStudy } from "./ImagingStudy";
-import { ChargeItem } from "./ChargeItem";
-import { Period } from "./Period";
-import { AdverseEvent } from "./AdverseEvent";
-import { url } from "./url";
-import { ContactDetail } from "./ContactDetail";
-import { DataRequirement } from "./DataRequirement";
-import { Media } from "./Media";
-import { CodeableConcept } from "./CodeableConcept";
-import { SubstancePolymer } from "./SubstancePolymer";
-import { QuestionnaireResponse } from "./QuestionnaireResponse";
-import { Coverage } from "./Coverage";
-import { Procedure } from "./Procedure";
-import { AuditEvent } from "./AuditEvent";
-import { PaymentReconciliation } from "./PaymentReconciliation";
-import { MedicinalProductManufactured } from "./MedicinalProductManufactured";
-import { CompartmentDefinition } from "./CompartmentDefinition";
-import { Organization } from "./Organization";
-import { ExplanationOfBenefit } from "./ExplanationOfBenefit";
-import { Composition } from "./Composition";
-import { SimpleQuantity } from "./SimpleQuantity";
-import { CoverageEligibilityResponse } from "./CoverageEligibilityResponse";
-import { DocumentReference } from "./DocumentReference";
-import { EventDefinition } from "./EventDefinition";
-import { SubstanceProtein } from "./SubstanceProtein";
-import { TerminologyCapabilities } from "./TerminologyCapabilities";
-import { Encounter } from "./Encounter";
-import { ImplementationGuide } from "./ImplementationGuide";
-import { EvidenceVariable } from "./EvidenceVariable";
-import { ObservationDefinition } from "./ObservationDefinition";
-import { DiagnosticReport } from "./DiagnosticReport";
-import { ExampleScenario } from "./ExampleScenario";
-import { ResearchDefinition } from "./ResearchDefinition";
-import { Parameters } from "./Parameters";
-import { SearchParameter } from "./SearchParameter";
-import { MedicinalProductInteraction } from "./MedicinalProductInteraction";
-import { CodeSystem } from "./CodeSystem";
-import { MessageDefinition } from "./MessageDefinition";
-import { NutritionOrder } from "./NutritionOrder";
-import { xhtml } from "./xhtml";
-import { VerificationResult } from "./VerificationResult";
-import { MedicationAdministration } from "./MedicationAdministration";
-import { CatalogEntry } from "./CatalogEntry";
-import { Flag } from "./Flag";
-import { DeviceUseStatement } from "./DeviceUseStatement";
-import { TriggerDefinition } from "./TriggerDefinition";
-import { uri } from "./uri";
-import { Contract } from "./Contract";
-import { Invoice } from "./Invoice";
-import { MarketingStatus } from "./MarketingStatus";
-import { Count } from "./Count";
-import { PaymentNotice } from "./PaymentNotice";
-import { Location } from "./Location";
-import { Claim } from "./Claim";
-import { Specimen } from "./Specimen";
-import { MedicationStatement } from "./MedicationStatement";
-import { EnrollmentResponse } from "./EnrollmentResponse";
-import { Evidence } from "./Evidence";
-import { Bundle } from "./Bundle";
-import { ResearchElementDefinition } from "./ResearchElementDefinition";
-import { Expression } from "./Expression";
-import { Coding } from "./Coding";
-import { BodyStructure } from "./BodyStructure";
-import { id } from "./id";
-import { MedicinalProduct } from "./MedicinalProduct";
-import { dateTime } from "./dateTime";
-import { ResearchStudy } from "./ResearchStudy";
-import { Dosage } from "./Dosage";
-import { AppointmentResponse } from "./AppointmentResponse";
-import { MedicinalProductIndication } from "./MedicinalProductIndication";
-import { Measure } from "./Measure";
-import { Person } from "./Person";
-import { InsurancePlan } from "./InsurancePlan";
-import { Patient } from "./Patient";
-import { EffectEvidenceSynthesis } from "./EffectEvidenceSynthesis";
-import { ResearchSubject } from "./ResearchSubject";
-import { Medication } from "./Medication";
-import { Range } from "./Range";
-import { ConceptMap } from "./ConceptMap";
-import { CoverageEligibilityRequest } from "./CoverageEligibilityRequest";
-import { Population } from "./Population";
-import { SubstanceSourceMaterial } from "./SubstanceSourceMaterial";
-import { VisionPrescription } from "./VisionPrescription";
-import { oid } from "./oid";
-import { MolecularSequence } from "./MolecularSequence";
-import { MedicinalProductUndesirableEffect } from "./MedicinalProductUndesirableEffect";
-import { OperationOutcome } from "./OperationOutcome";
-import { MessageHeader } from "./MessageHeader";
-import { ContactPoint } from "./ContactPoint";
-import { uuid } from "./uuid";
-import { Signature } from "./Signature";
-import { AllergyIntolerance } from "./AllergyIntolerance";
-import { SubstanceReferenceInformation } from "./SubstanceReferenceInformation";
-import { SupplyDelivery } from "./SupplyDelivery";
-import { EpisodeOfCare } from "./EpisodeOfCare";
-import { PractitionerRole } from "./PractitionerRole";
-import { Library } from "./Library";
-import { Practitioner } from "./Practitioner";
-import { MedicationRequest } from "./MedicationRequest";
-import { ImmunizationRecommendation } from "./ImmunizationRecommendation";
-import { RelatedArtifact } from "./RelatedArtifact";
-import { Timing } from "./Timing";
-import { Immunization } from "./Immunization";
-import { GraphDefinition } from "./GraphDefinition";
-import { Account } from "./Account";
-import { MedicinalProductIngredient } from "./MedicinalProductIngredient";
-import { ProdCharacteristic } from "./ProdCharacteristic";
-import { Meta } from "./Meta";
-import { Quantity } from "./Quantity";
-import { MeasureReport } from "./MeasureReport";
-import { Distance } from "./Distance";
-import { canonical } from "./canonical";
-import { HumanName } from "./HumanName";
-import { DeviceMetric } from "./DeviceMetric";
-import { Duration } from "./Duration";
-import { SubstanceAmount } from "./SubstanceAmount";
-import { Goal } from "./Goal";
-import { time } from "./time";
-import { MedicationKnowledge } from "./MedicationKnowledge";
-import { ClaimResponse } from "./ClaimResponse";
-import { DeviceDefinition } from "./DeviceDefinition";
-import { Slot } from "./Slot";
-import { ValueSet } from "./ValueSet";
-import { MedicinalProductAuthorization } from "./MedicinalProductAuthorization";
-import { StructureDefinition } from "./StructureDefinition";
-import { integer } from "./integer";
-import { MedicinalProductContraindication } from "./MedicinalProductContraindication";
-import { ElementDefinition } from "./ElementDefinition";
-import { DeviceRequest } from "./DeviceRequest";
-import { List } from "./List";
-import { Questionnaire } from "./Questionnaire";
-import { DomainResource } from "./DomainResource";
-import { Endpoint } from "./Endpoint";
-import { NamingSystem } from "./NamingSystem";
-import { MedicinalProductPackaged } from "./MedicinalProductPackaged";
-import { Basic } from "./Basic";
-import { Money } from "./Money";
-import { Binary } from "./Binary";
-import { PlanDefinition } from "./PlanDefinition";
-import { Subscription } from "./Subscription";
-import { SampledData } from "./SampledData";
-import { ProductShelfLife } from "./ProductShelfLife";
-import { RelatedPerson } from "./RelatedPerson";
-import { SubstanceSpecification } from "./SubstanceSpecification";
-import { date } from "./date";
-import { Ratio } from "./Ratio";
-import { markdown } from "./markdown";
-import { SubstanceNucleicAcid } from "./SubstanceNucleicAcid";
-import { GuidanceResponse } from "./GuidanceResponse";
-import { ClinicalImpression } from "./ClinicalImpression";
-import { OrganizationAffiliation } from "./OrganizationAffiliation";
-import { Resource } from "./Resource";
-import { Condition } from "./Condition";
-import { Extension } from "./Extension";
-import { CapabilityStatement } from "./CapabilityStatement";
-import { HealthcareService } from "./HealthcareService";
-import { SpecimenDefinition } from "./SpecimenDefinition";
-import { ParameterDefinition } from "./ParameterDefinition";
-import { RiskAssessment } from "./RiskAssessment";
-import { OperationDefinition } from "./OperationDefinition";
-import { ActivityDefinition } from "./ActivityDefinition";
-import { Schedule } from "./Schedule";
-import { BiologicallyDerivedProduct } from "./BiologicallyDerivedProduct";
-import { Group } from "./Group";
-import { MedicinalProductPharmaceutical } from "./MedicinalProductPharmaceutical";
-import { base64Binary } from "./base64Binary";
-import { FamilyMemberHistory } from "./FamilyMemberHistory";
-import { ServiceRequest } from "./ServiceRequest";
-import { DetectedIssue } from "./DetectedIssue";
-import { instant } from "./instant";
-import { Device } from "./Device";
-import { RequestGroup } from "./RequestGroup";
-import { TestScript } from "./TestScript";
-import { RiskEvidenceSynthesis } from "./RiskEvidenceSynthesis";
-import { SupplyRequest } from "./SupplyRequest";
-import { Element } from "./Element";
-import { Reference } from "./Reference";
-import { code } from "./code";
-import { Task } from "./Task";
-import { Identifier } from "./Identifier";
-import { CommunicationRequest } from "./CommunicationRequest";
-import { EnrollmentRequest } from "./EnrollmentRequest";
-import { ChargeItemDefinition } from "./ChargeItemDefinition";
-import { Substance } from "./Substance";
-import { Provenance } from "./Provenance";
-import { Consent } from "./Consent";
-import { BackboneElement } from "./BackboneElement";
-import { CarePlan } from "./CarePlan";
-import { Narrative } from "./Narrative";
-import { decimal } from "./decimal";
-import { TestReport } from "./TestReport";
-import { Observation } from "./Observation";
-import { DocumentManifest } from "./DocumentManifest";
-import { Contributor } from "./Contributor";
-export type ResourceTypeMap = {
-    ImmunizationEvaluation: ImmunizationEvaluation;
-    Appointment: Appointment;
-    StructureMap: StructureMap;
-    Address: Address;
-    CareTeam: CareTeam;
-    UsageContext: UsageContext;
-    Linkage: Linkage;
-    Annotation: Annotation;
-    Age: Age;
-    Attachment: Attachment;
-    positiveInt: positiveInt;
-    unsignedInt: unsignedInt;
-    Communication: Communication;
-    MedicationDispense: MedicationDispense;
-    ImagingStudy: ImagingStudy;
-    ChargeItem: ChargeItem;
-    Period: Period;
-    AdverseEvent: AdverseEvent;
-    url: url;
-    ContactDetail: ContactDetail;
-    DataRequirement: DataRequirement;
-    Media: Media;
-    CodeableConcept: CodeableConcept;
-    SubstancePolymer: SubstancePolymer;
-    QuestionnaireResponse: QuestionnaireResponse;
-    Coverage: Coverage;
-    Procedure: Procedure;
-    AuditEvent: AuditEvent;
-    PaymentReconciliation: PaymentReconciliation;
-    MedicinalProductManufactured: MedicinalProductManufactured;
-    CompartmentDefinition: CompartmentDefinition;
-    Organization: Organization;
-    ExplanationOfBenefit: ExplanationOfBenefit;
-    Composition: Composition;
-    SimpleQuantity: SimpleQuantity;
-    CoverageEligibilityResponse: CoverageEligibilityResponse;
-    DocumentReference: DocumentReference;
-    EventDefinition: EventDefinition;
-    SubstanceProtein: SubstanceProtein;
-    TerminologyCapabilities: TerminologyCapabilities;
-    Encounter: Encounter;
-    ImplementationGuide: ImplementationGuide;
-    EvidenceVariable: EvidenceVariable;
-    ObservationDefinition: ObservationDefinition;
-    DiagnosticReport: DiagnosticReport;
-    ExampleScenario: ExampleScenario;
-    ResearchDefinition: ResearchDefinition;
-    Parameters: Parameters;
-    SearchParameter: SearchParameter;
-    MedicinalProductInteraction: MedicinalProductInteraction;
-    CodeSystem: CodeSystem;
-    MessageDefinition: MessageDefinition;
-    NutritionOrder: NutritionOrder;
-    xhtml: xhtml;
-    VerificationResult: VerificationResult;
-    MedicationAdministration: MedicationAdministration;
-    CatalogEntry: CatalogEntry;
-    Flag: Flag;
-    DeviceUseStatement: DeviceUseStatement;
-    TriggerDefinition: TriggerDefinition;
-    uri: uri;
-    Contract: Contract;
-    Invoice: Invoice;
-    MarketingStatus: MarketingStatus;
-    Count: Count;
-    PaymentNotice: PaymentNotice;
-    Location: Location;
-    Claim: Claim;
-    Specimen: Specimen;
-    MedicationStatement: MedicationStatement;
-    EnrollmentResponse: EnrollmentResponse;
-    Evidence: Evidence;
-    Bundle: Bundle;
-    ResearchElementDefinition: ResearchElementDefinition;
-    Expression: Expression;
-    Coding: Coding;
-    BodyStructure: BodyStructure;
-    id: id;
-    MedicinalProduct: MedicinalProduct;
-    dateTime: dateTime;
-    ResearchStudy: ResearchStudy;
-    Dosage: Dosage;
-    AppointmentResponse: AppointmentResponse;
-    MedicinalProductIndication: MedicinalProductIndication;
-    Measure: Measure;
-    Person: Person;
-    InsurancePlan: InsurancePlan;
-    Patient: Patient;
-    EffectEvidenceSynthesis: EffectEvidenceSynthesis;
-    ResearchSubject: ResearchSubject;
-    Medication: Medication;
-    Range: Range;
-    ConceptMap: ConceptMap;
-    CoverageEligibilityRequest: CoverageEligibilityRequest;
-    Population: Population;
-    SubstanceSourceMaterial: SubstanceSourceMaterial;
-    VisionPrescription: VisionPrescription;
-    oid: oid;
-    MolecularSequence: MolecularSequence;
-    MedicinalProductUndesirableEffect: MedicinalProductUndesirableEffect;
-    OperationOutcome: OperationOutcome;
-    MessageHeader: MessageHeader;
-    ContactPoint: ContactPoint;
-    uuid: uuid;
-    Signature: Signature;
-    AllergyIntolerance: AllergyIntolerance;
-    SubstanceReferenceInformation: SubstanceReferenceInformation;
-    SupplyDelivery: SupplyDelivery;
-    EpisodeOfCare: EpisodeOfCare;
-    PractitionerRole: PractitionerRole;
-    Library: Library;
-    Practitioner: Practitioner;
-    MedicationRequest: MedicationRequest;
-    ImmunizationRecommendation: ImmunizationRecommendation;
-    RelatedArtifact: RelatedArtifact;
-    Timing: Timing;
-    Immunization: Immunization;
-    GraphDefinition: GraphDefinition;
-    Account: Account;
-    MedicinalProductIngredient: MedicinalProductIngredient;
-    ProdCharacteristic: ProdCharacteristic;
-    Meta: Meta;
-    Quantity: Quantity;
-    MeasureReport: MeasureReport;
-    Distance: Distance;
-    canonical: canonical;
-    HumanName: HumanName;
-    DeviceMetric: DeviceMetric;
-    Duration: Duration;
-    SubstanceAmount: SubstanceAmount;
-    Goal: Goal;
-    time: time;
-    MedicationKnowledge: MedicationKnowledge;
-    ClaimResponse: ClaimResponse;
-    DeviceDefinition: DeviceDefinition;
-    Slot: Slot;
-    ValueSet: ValueSet;
-    MedicinalProductAuthorization: MedicinalProductAuthorization;
-    StructureDefinition: StructureDefinition;
-    integer: integer;
-    MedicinalProductContraindication: MedicinalProductContraindication;
-    ElementDefinition: ElementDefinition;
-    DeviceRequest: DeviceRequest;
-    List: List;
-    Questionnaire: Questionnaire;
-    DomainResource: DomainResource;
-    Endpoint: Endpoint;
-    NamingSystem: NamingSystem;
-    MedicinalProductPackaged: MedicinalProductPackaged;
-    Basic: Basic;
-    Money: Money;
-    Binary: Binary;
-    PlanDefinition: PlanDefinition;
-    Subscription: Subscription;
-    SampledData: SampledData;
-    ProductShelfLife: ProductShelfLife;
-    RelatedPerson: RelatedPerson;
-    SubstanceSpecification: SubstanceSpecification;
-    date: date;
-    Ratio: Ratio;
-    markdown: markdown;
-    SubstanceNucleicAcid: SubstanceNucleicAcid;
-    GuidanceResponse: GuidanceResponse;
-    ClinicalImpression: ClinicalImpression;
-    OrganizationAffiliation: OrganizationAffiliation;
-    Resource: Resource;
-    Condition: Condition;
-    Extension: Extension;
-    CapabilityStatement: CapabilityStatement;
-    HealthcareService: HealthcareService;
-    SpecimenDefinition: SpecimenDefinition;
-    ParameterDefinition: ParameterDefinition;
-    RiskAssessment: RiskAssessment;
-    OperationDefinition: OperationDefinition;
-    ActivityDefinition: ActivityDefinition;
-    Schedule: Schedule;
-    BiologicallyDerivedProduct: BiologicallyDerivedProduct;
-    Group: Group;
-    MedicinalProductPharmaceutical: MedicinalProductPharmaceutical;
-    base64Binary: base64Binary;
-    FamilyMemberHistory: FamilyMemberHistory;
-    ServiceRequest: ServiceRequest;
-    DetectedIssue: DetectedIssue;
-    instant: instant;
-    Device: Device;
-    RequestGroup: RequestGroup;
-    TestScript: TestScript;
-    RiskEvidenceSynthesis: RiskEvidenceSynthesis;
-    SupplyRequest: SupplyRequest;
-    Element: Element;
-    Reference: Reference;
-    code: code;
-    Task: Task;
-    Identifier: Identifier;
-    CommunicationRequest: CommunicationRequest;
-    EnrollmentRequest: EnrollmentRequest;
-    ChargeItemDefinition: ChargeItemDefinition;
-    Substance: Substance;
-    Provenance: Provenance;
-    Consent: Consent;
-    BackboneElement: BackboneElement;
-    CarePlan: CarePlan;
-    Narrative: Narrative;
-    decimal: decimal;
-    TestReport: TestReport;
-    Observation: Observation;
-    DocumentManifest: DocumentManifest;
-    Contributor: Contributor;
-};
-export type ResourceType = keyof ResourceTypeMap;
-export interface SearchParams extends Record<ResourceType, unknown> {
-    DeviceRequest: {
-        device: `${ResourceType}/${string}`;
-        "based-on": `${ResourceType}/${string}`;
-        requester: `${ResourceType}/${string}`;
-        "instantiates-uri": uri;
-        "prior-request": `${ResourceType}/${string}`;
-        encounter: `${ResourceType}/${string}`;
-        "group-identifier": string;
-        status: string;
-        insurance: `${ResourceType}/${string}`;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        "event-date": date;
-        intent: string;
-        patient: `${ResourceType}/${string}`;
-        "instantiates-canonical": `${ResourceType}/${string}`;
-        code: string;
-        performer: `${ResourceType}/${string}`;
-        "authored-on": date;
-    };
-    ServiceRequest: {
-        priority: string;
-        "based-on": `${ResourceType}/${string}`;
-        requester: `${ResourceType}/${string}`;
-        "body-site": string;
-        "instantiates-uri": uri;
-        authored: date;
-        requisition: string;
-        status: string;
-        subject: `${ResourceType}/${string}`;
-        specimen: `${ResourceType}/${string}`;
-        occurrence: date;
-        intent: string;
-        replaces: `${ResourceType}/${string}`;
-        category: string;
-        "instantiates-canonical": `${ResourceType}/${string}`;
-        "performer-type": string;
-        performer: `${ResourceType}/${string}`;
-    };
-    DeviceMetric: {
-        parent: `${ResourceType}/${string}`;
-        identifier: string;
-        source: `${ResourceType}/${string}`;
-        type: string;
-        category: string;
-    };
-    CarePlan: {
-        "activity-code": string;
-        "based-on": `${ResourceType}/${string}`;
-        "instantiates-uri": uri;
-        condition: `${ResourceType}/${string}`;
-        encounter: `${ResourceType}/${string}`;
-        "part-of": `${ResourceType}/${string}`;
-        "activity-reference": `${ResourceType}/${string}`;
-        "care-team": `${ResourceType}/${string}`;
-        status: string;
-        subject: `${ResourceType}/${string}`;
-        intent: string;
-        date: date;
-        replaces: `${ResourceType}/${string}`;
-        category: string;
-        "instantiates-canonical": `${ResourceType}/${string}`;
-        "activity-date": date;
-        performer: `${ResourceType}/${string}`;
-        goal: `${ResourceType}/${string}`;
-    };
-    Observation: {
-        "dna-variant": string;
-        "component-value-quantity": string;
-        device: `${ResourceType}/${string}`;
-        "amino-acid-change": string;
-        "component-value-concept": string;
-        "based-on": `${ResourceType}/${string}`;
-        "combo-data-absent-reason": string;
-        "gene-dnavariant": string;
-        "has-member": `${ResourceType}/${string}`;
-        "component-data-absent-reason": string;
-        method: string;
-        focus: `${ResourceType}/${string}`;
-        "value-date": date;
-        "combo-code": string;
-        "value-quantity": string;
-        "part-of": `${ResourceType}/${string}`;
-        "combo-value-concept": string;
-        "component-code": string;
-        "gene-identifier": string;
-        status: string;
-        subject: `${ResourceType}/${string}`;
-        specimen: `${ResourceType}/${string}`;
-        "combo-value-quantity": string;
-        "value-string": string;
-        "gene-amino-acid-change": string;
-        category: string;
-        "data-absent-reason": string;
-        "value-concept": string;
-        "derived-from": `${ResourceType}/${string}`;
-        performer: `${ResourceType}/${string}`;
-    };
-    EnrollmentRequest: {
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-    };
-    Group: {
-        member: `${ResourceType}/${string}`;
-        "managing-entity": `${ResourceType}/${string}`;
-        value: string;
-        identifier: string;
-        characteristic: string;
-        type: string;
-        exclude: string;
-        actual: string;
-        code: string;
-    };
-    MessageDefinition: {
-        "context-quantity": string;
-        url: uri;
-        "context-type": string;
-        parent: `${ResourceType}/${string}`;
-        focus: string;
-        event: string;
-        name: string;
-        context: string;
-        status: string;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        category: string;
-        description: string;
-    };
-    Appointment: {
-        specialty: string;
-        "based-on": `${ResourceType}/${string}`;
-        "service-category": string;
-        "reason-reference": `${ResourceType}/${string}`;
-        slot: `${ResourceType}/${string}`;
-        practitioner: `${ResourceType}/${string}`;
-        "service-type": string;
-        location: `${ResourceType}/${string}`;
-        "appointment-type": string;
-        status: string;
-        identifier: string;
-        "supporting-info": `${ResourceType}/${string}`;
-        date: date;
-        patient: `${ResourceType}/${string}`;
-        "part-status": string;
-        "reason-code": string;
-        actor: `${ResourceType}/${string}`;
-    };
-    QuestionnaireResponse: {
-        "based-on": `${ResourceType}/${string}`;
-        author: `${ResourceType}/${string}`;
-        authored: date;
-        encounter: `${ResourceType}/${string}`;
-        "part-of": `${ResourceType}/${string}`;
-        status: string;
-        identifier: string;
-        "item-subject": `${ResourceType}/${string}`;
-        subject: `${ResourceType}/${string}`;
-        questionnaire: `${ResourceType}/${string}`;
-        source: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-    };
-    EffectEvidenceSynthesis: {
-        "context-quantity": string;
-        url: uri;
-        "context-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        effective: date;
-        description: string;
-    };
-    MedicinalProductContraindication: {
-        subject: `${ResourceType}/${string}`;
-    };
-    EpisodeOfCare: {
-        condition: `${ResourceType}/${string}`;
-        status: string;
-        "incoming-referral": `${ResourceType}/${string}`;
-        organization: `${ResourceType}/${string}`;
-        "care-manager": `${ResourceType}/${string}`;
-    };
-    Evidence: {
-        "context-quantity": string;
-        url: uri;
-        "depends-on": `${ResourceType}/${string}`;
-        "context-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        predecessor: `${ResourceType}/${string}`;
-        "derived-from": `${ResourceType}/${string}`;
-        effective: date;
-        description: string;
-        "composed-of": `${ResourceType}/${string}`;
-        successor: `${ResourceType}/${string}`;
-        topic: string;
-    };
-    SupplyDelivery: {
-        status: string;
-        receiver: `${ResourceType}/${string}`;
-        supplier: `${ResourceType}/${string}`;
-    };
-    AdverseEvent: {
-        resultingcondition: `${ResourceType}/${string}`;
-        event: string;
-        seriousness: string;
-        location: `${ResourceType}/${string}`;
-        study: `${ResourceType}/${string}`;
-        subject: `${ResourceType}/${string}`;
-        recorder: `${ResourceType}/${string}`;
-        substance: `${ResourceType}/${string}`;
-        actuality: string;
-        date: date;
-        category: string;
-        severity: string;
-    };
-    Endpoint: {
-        "connection-type": string;
-        name: string;
-        status: string;
-        identifier: string;
-        organization: `${ResourceType}/${string}`;
-        "payload-type": string;
-    };
-    CompartmentDefinition: {
-        resource: string;
-        code: string;
-    };
-    DetectedIssue: {
-        implicated: `${ResourceType}/${string}`;
-        identified: date;
-        author: `${ResourceType}/${string}`;
-        code: string;
-    };
-    MedicationAdministration: {
-        device: `${ResourceType}/${string}`;
-        context: `${ResourceType}/${string}`;
-        status: string;
-        request: `${ResourceType}/${string}`;
-        subject: `${ResourceType}/${string}`;
-        "reason-given": string;
-        medication: `${ResourceType}/${string}`;
-        "reason-not-given": string;
-        "effective-time": date;
-        performer: `${ResourceType}/${string}`;
-    };
-    EvidenceVariable: {
-        "context-quantity": string;
-        url: uri;
-        "depends-on": `${ResourceType}/${string}`;
-        "context-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        predecessor: `${ResourceType}/${string}`;
-        "derived-from": `${ResourceType}/${string}`;
-        effective: date;
-        description: string;
-        "composed-of": `${ResourceType}/${string}`;
-        successor: `${ResourceType}/${string}`;
-        topic: string;
-    };
-    ImplementationGuide: {
-        resource: `${ResourceType}/${string}`;
-        experimental: string;
-        "depends-on": `${ResourceType}/${string}`;
-        global: `${ResourceType}/${string}`;
-    };
-    Goal: {
-        "target-date": date;
-        "achievement-status": string;
-        "lifecycle-status": string;
-        subject: `${ResourceType}/${string}`;
-        category: string;
-        "start-date": date;
-    };
-    Communication: {
-        sent: date;
-        "based-on": `${ResourceType}/${string}`;
-        "instantiates-uri": uri;
-        recipient: `${ResourceType}/${string}`;
-        encounter: `${ResourceType}/${string}`;
-        medium: string;
-        "part-of": `${ResourceType}/${string}`;
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        received: date;
-        patient: `${ResourceType}/${string}`;
-        category: string;
-        "instantiates-canonical": `${ResourceType}/${string}`;
-        sender: `${ResourceType}/${string}`;
-    };
-    Schedule: {
-        specialty: string;
-        "service-category": string;
-        "service-type": string;
-        identifier: string;
-        date: date;
-        active: string;
-        actor: `${ResourceType}/${string}`;
-    };
-    DocumentReference: {
-        author: `${ResourceType}/${string}`;
-        related: `${ResourceType}/${string}`;
-        "security-label": string;
-        event: string;
-        setting: string;
-        location: uri;
-        status: string;
-        subject: `${ResourceType}/${string}`;
-        authenticator: `${ResourceType}/${string}`;
-        facility: string;
-        date: date;
-        category: string;
-        contenttype: string;
-        period: date;
-        custodian: `${ResourceType}/${string}`;
-        language: string;
-        description: string;
-        format: string;
-        relation: string;
-        relatesto: `${ResourceType}/${string}`;
-    };
-    OrganizationAffiliation: {
-        role: string;
-        specialty: string;
-        email: string;
-        network: `${ResourceType}/${string}`;
-        location: `${ResourceType}/${string}`;
-        identifier: string;
-        phone: string;
-        date: date;
-        endpoint: `${ResourceType}/${string}`;
-        telecom: string;
-        service: `${ResourceType}/${string}`;
-        active: string;
-        "participating-organization": `${ResourceType}/${string}`;
-        "primary-organization": `${ResourceType}/${string}`;
-    };
-    DeviceDefinition: {
-        parent: `${ResourceType}/${string}`;
-        identifier: string;
-        type: string;
-    };
-    Coverage: {
-        "class-type": string;
-        "policy-holder": `${ResourceType}/${string}`;
-        "class-value": string;
-        beneficiary: `${ResourceType}/${string}`;
-        status: string;
-        identifier: string;
-        payor: `${ResourceType}/${string}`;
-        type: string;
-        patient: `${ResourceType}/${string}`;
-        subscriber: `${ResourceType}/${string}`;
-        dependent: string;
-    };
-    AuditEvent: {
-        "agent-name": string;
-        "entity-role": string;
-        subtype: string;
-        agent: `${ResourceType}/${string}`;
-        "entity-type": string;
-        altid: string;
-        "entity-name": string;
-        address: string;
-        action: string;
-        site: string;
-        policy: uri;
-        source: `${ResourceType}/${string}`;
-        "agent-role": string;
-        type: string;
-        date: date;
-        patient: `${ResourceType}/${string}`;
-        entity: `${ResourceType}/${string}`;
-        outcome: string;
-    };
-    MessageHeader: {
-        destination: string;
-        "source-uri": uri;
-        author: `${ResourceType}/${string}`;
-        focus: `${ResourceType}/${string}`;
-        event: string;
-        responsible: `${ResourceType}/${string}`;
-        enterer: `${ResourceType}/${string}`;
-        receiver: `${ResourceType}/${string}`;
-        "response-id": string;
-        "destination-uri": uri;
-        source: string;
-        target: `${ResourceType}/${string}`;
-        sender: `${ResourceType}/${string}`;
-        code: string;
-    };
-    Contract: {
-        url: uri;
-        signer: `${ResourceType}/${string}`;
-        authority: `${ResourceType}/${string}`;
-        issued: date;
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        domain: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-        instantiates: uri;
-    };
-    TestReport: {
-        issued: date;
-        tester: string;
-        participant: uri;
-        identifier: string;
-        testscript: `${ResourceType}/${string}`;
-        result: string;
-    };
-    CodeSystem: {
-        supplements: `${ResourceType}/${string}`;
-        identifier: string;
-        system: uri;
-        "content-mode": string;
-        language: string;
-        code: string;
-    };
-    PlanDefinition: {
-        "context-quantity": string;
-        url: uri;
-        "depends-on": `${ResourceType}/${string}`;
-        "context-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        definition: `${ResourceType}/${string}`;
-        jurisdiction: string;
-        title: string;
-        type: string;
-        publisher: string;
-        version: string;
-        date: date;
-        predecessor: `${ResourceType}/${string}`;
-        "derived-from": `${ResourceType}/${string}`;
-        effective: date;
-        description: string;
-        "composed-of": `${ResourceType}/${string}`;
-        successor: `${ResourceType}/${string}`;
-        topic: string;
-    };
-    Invoice: {
-        totalnet: string;
-        "participant-role": string;
-        issuer: `${ResourceType}/${string}`;
-        recipient: `${ResourceType}/${string}`;
-        participant: `${ResourceType}/${string}`;
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        account: `${ResourceType}/${string}`;
-        totalgross: string;
-        type: string;
-        date: date;
-        patient: `${ResourceType}/${string}`;
-    };
-    ClaimResponse: {
-        created: date;
-        requestor: `${ResourceType}/${string}`;
-        "payment-date": date;
-        insurer: `${ResourceType}/${string}`;
-        disposition: string;
-        status: string;
-        request: `${ResourceType}/${string}`;
-        identifier: string;
-        patient: `${ResourceType}/${string}`;
-        use: string;
-        outcome: string;
-    };
-    ChargeItem: {
-        "performing-organization": `${ResourceType}/${string}`;
-        "requesting-organization": `${ResourceType}/${string}`;
-        "performer-function": string;
-        "performer-actor": `${ResourceType}/${string}`;
-        "entered-date": date;
-        quantity: string;
-        context: `${ResourceType}/${string}`;
-        enterer: `${ResourceType}/${string}`;
-        "price-override": string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        account: `${ResourceType}/${string}`;
-        occurrence: date;
-        patient: `${ResourceType}/${string}`;
-        service: `${ResourceType}/${string}`;
-        code: string;
-        "factor-override": number;
-    };
-    CoverageEligibilityResponse: {
-        created: date;
-        requestor: `${ResourceType}/${string}`;
-        insurer: `${ResourceType}/${string}`;
-        disposition: string;
-        status: string;
-        request: `${ResourceType}/${string}`;
-        identifier: string;
-        patient: `${ResourceType}/${string}`;
-        outcome: string;
-    };
-    BodyStructure: {
-        location: string;
-        identifier: string;
-        morphology: string;
-        patient: `${ResourceType}/${string}`;
-    };
-    ClinicalImpression: {
-        assessor: `${ResourceType}/${string}`;
-        "finding-code": string;
-        encounter: `${ResourceType}/${string}`;
-        investigation: `${ResourceType}/${string}`;
-        previous: `${ResourceType}/${string}`;
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        "finding-ref": `${ResourceType}/${string}`;
-        "supporting-info": `${ResourceType}/${string}`;
-        problem: `${ResourceType}/${string}`;
-    };
-    FamilyMemberHistory: {
-        "instantiates-uri": uri;
-        relationship: string;
-        status: string;
-        sex: string;
-        "instantiates-canonical": `${ResourceType}/${string}`;
-    };
-    MedicinalProductAuthorization: {
-        holder: `${ResourceType}/${string}`;
-        country: string;
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-    };
-    Composition: {
-        entry: `${ResourceType}/${string}`;
-        "related-id": string;
-        author: `${ResourceType}/${string}`;
-        "related-ref": `${ResourceType}/${string}`;
-        confidentiality: string;
-        attester: `${ResourceType}/${string}`;
-        section: string;
-        context: string;
-        status: string;
-        subject: `${ResourceType}/${string}`;
-        title: string;
-        category: string;
-        period: date;
-    };
-    PractitionerRole: {
-        role: string;
-        specialty: string;
-        practitioner: `${ResourceType}/${string}`;
-        location: `${ResourceType}/${string}`;
-        identifier: string;
-        date: date;
-        endpoint: `${ResourceType}/${string}`;
-        service: `${ResourceType}/${string}`;
-        active: string;
-        organization: `${ResourceType}/${string}`;
-    };
-    HealthcareService: {
-        specialty: string;
-        "service-category": string;
-        "coverage-area": `${ResourceType}/${string}`;
-        "service-type": string;
-        name: string;
-        location: `${ResourceType}/${string}`;
-        identifier: string;
-        characteristic: string;
-        endpoint: `${ResourceType}/${string}`;
-        active: string;
-        organization: `${ResourceType}/${string}`;
-        program: string;
-    };
-    Patient: {
-        "address-use": string;
-        "address-country": string;
-        "part-agree": `${ResourceType}/${string}`;
-        "death-date": date;
-        mothersMaidenName: string;
-        gender: string;
-        email: string;
-        "address-city": string;
-        name: string;
-        "general-practitioner": `${ResourceType}/${string}`;
-        "address-state": string;
-        address: string;
-        identifier: string;
-        given: string;
-        link: `${ResourceType}/${string}`;
-        family: string;
-        phone: string;
-        phonetic: string;
-        birthdate: date;
-        telecom: string;
-        active: string;
-        language: string;
-        organization: `${ResourceType}/${string}`;
-        deceased: string;
-        "address-postalcode": string;
-    };
-    MedicationDispense: {
-        destination: `${ResourceType}/${string}`;
-        prescription: `${ResourceType}/${string}`;
-        whenprepared: date;
-        context: `${ResourceType}/${string}`;
-        subject: `${ResourceType}/${string}`;
-        receiver: `${ResourceType}/${string}`;
-        type: string;
-        whenhandedover: date;
-        performer: `${ResourceType}/${string}`;
-        responsibleparty: `${ResourceType}/${string}`;
-    };
-    DeviceUseStatement: {
-        device: `${ResourceType}/${string}`;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-    };
-    ImmunizationEvaluation: {
-        "dose-status": string;
-        status: string;
-        identifier: string;
-        "target-disease": string;
-        date: date;
-        patient: `${ResourceType}/${string}`;
-        "immunization-event": `${ResourceType}/${string}`;
-    };
-    Library: {
-        "context-quantity": string;
-        url: uri;
-        "depends-on": `${ResourceType}/${string}`;
-        "context-type": string;
-        "content-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        title: string;
-        type: string;
-        publisher: string;
-        version: string;
-        date: date;
-        predecessor: `${ResourceType}/${string}`;
-        "derived-from": `${ResourceType}/${string}`;
-        effective: date;
-        description: string;
-        "composed-of": `${ResourceType}/${string}`;
-        successor: `${ResourceType}/${string}`;
-        topic: string;
-    };
-    Basic: {
-        created: date;
-        author: `${ResourceType}/${string}`;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-        code: string;
-    };
-    Slot: {
-        specialty: string;
-        "service-category": string;
-        "service-type": string;
-        schedule: `${ResourceType}/${string}`;
-        "appointment-type": string;
-        status: string;
-        start: date;
-        identifier: string;
-    };
-    ActivityDefinition: {
-        "context-quantity": string;
-        url: uri;
-        "depends-on": `${ResourceType}/${string}`;
-        "context-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        predecessor: `${ResourceType}/${string}`;
-        "derived-from": `${ResourceType}/${string}`;
-        effective: date;
-        description: string;
-        "composed-of": `${ResourceType}/${string}`;
-        successor: `${ResourceType}/${string}`;
-        topic: string;
-    };
-    Bundle: {
-        message: `${ResourceType}/${string}`;
-        timestamp: date;
-        identifier: string;
-        composition: `${ResourceType}/${string}`;
-        type: string;
-    };
-    MedicinalProductInteraction: {
-        subject: `${ResourceType}/${string}`;
-    };
-    MolecularSequence: {
-        chromosome: string;
-        "window-end": number;
-        "window-start": number;
-        referenceseqid: string;
-        "variant-start": number;
-        identifier: string;
-        type: string;
-        "variant-end": number;
-        patient: `${ResourceType}/${string}`;
-    };
-    Specimen: {
-        parent: `${ResourceType}/${string}`;
-        accession: string;
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        collected: date;
-        bodysite: string;
-        type: string;
-        patient: `${ResourceType}/${string}`;
-        "container-id": string;
-        container: string;
-        collector: `${ResourceType}/${string}`;
-    };
-    DiagnosticReport: {
-        media: `${ResourceType}/${string}`;
-        "based-on": `${ResourceType}/${string}`;
-        issued: date;
-        conclusion: string;
-        status: string;
-        "assessed-condition": `${ResourceType}/${string}`;
-        subject: `${ResourceType}/${string}`;
-        specimen: `${ResourceType}/${string}`;
-        category: string;
-        result: `${ResourceType}/${string}`;
-        "results-interpreter": `${ResourceType}/${string}`;
-        performer: `${ResourceType}/${string}`;
-    };
-    Subscription: {
-        url: uri;
-        status: string;
-        type: string;
-        criteria: string;
-        payload: string;
-        contact: string;
-    };
-    RequestGroup: {
-        priority: string;
-        "instantiates-uri": uri;
-        author: `${ResourceType}/${string}`;
-        authored: date;
-        encounter: `${ResourceType}/${string}`;
-        "group-identifier": string;
-        participant: `${ResourceType}/${string}`;
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        intent: string;
-        patient: `${ResourceType}/${string}`;
-        "instantiates-canonical": `${ResourceType}/${string}`;
-        code: string;
-    };
-    Provenance: {
-        agent: `${ResourceType}/${string}`;
-        recorded: date;
-        "agent-type": string;
-        location: `${ResourceType}/${string}`;
-        when: date;
-        "signature-type": string;
-        "agent-role": string;
-        target: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-        entity: `${ResourceType}/${string}`;
-    };
-    MedicinalProduct: {
-        name: string;
-        identifier: string;
-        "name-language": string;
-    };
-    ChargeItemDefinition: {
-        "context-quantity": string;
-        url: uri;
-        "context-type": string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        effective: date;
-        description: string;
-    };
-    Practitioner: {
-        name: string;
-        identifier: string;
-        communication: string;
-        active: string;
-    };
-    MedicinalProductPackaged: {
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-    };
-    Flag: {
-        author: `${ResourceType}/${string}`;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-    };
-    ExplanationOfBenefit: {
-        coverage: `${ResourceType}/${string}`;
-        created: date;
-        payee: `${ResourceType}/${string}`;
-        "detail-udi": `${ResourceType}/${string}`;
-        "subdetail-udi": `${ResourceType}/${string}`;
-        encounter: `${ResourceType}/${string}`;
-        disposition: string;
-        provider: `${ResourceType}/${string}`;
-        "procedure-udi": `${ResourceType}/${string}`;
-        claim: `${ResourceType}/${string}`;
-        "care-team": `${ResourceType}/${string}`;
-        enterer: `${ResourceType}/${string}`;
-        status: string;
-        identifier: string;
-        facility: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-        "item-udi": `${ResourceType}/${string}`;
-    };
-    Linkage: {
-        author: `${ResourceType}/${string}`;
-        item: `${ResourceType}/${string}`;
-        source: `${ResourceType}/${string}`;
-    };
-    MedicinalProductPharmaceutical: {
-        "target-species": string;
-        route: string;
-        identifier: string;
-    };
-    Immunization: {
-        "reason-reference": `${ResourceType}/${string}`;
-        manufacturer: `${ResourceType}/${string}`;
-        reaction: `${ResourceType}/${string}`;
-        location: `${ResourceType}/${string}`;
-        status: string;
-        "target-disease": string;
-        "reaction-date": date;
-        "status-reason": string;
-        series: string;
-        "vaccine-code": string;
-        "reason-code": string;
-        "lot-number": string;
-        performer: `${ResourceType}/${string}`;
-    };
-    MedicationKnowledge: {
-        manufacturer: `${ResourceType}/${string}`;
-        "ingredient-code": string;
-        "monitoring-program-name": string;
-        status: string;
-        "monitoring-program-type": string;
-        ingredient: `${ResourceType}/${string}`;
-        "monograph-type": string;
-        doseform: string;
-        "classification-type": string;
-        code: string;
-        "source-cost": string;
-        monograph: `${ResourceType}/${string}`;
-        classification: string;
-    };
-    ResearchSubject: {
-        individual: `${ResourceType}/${string}`;
-        status: string;
-        study: `${ResourceType}/${string}`;
-        identifier: string;
-        date: date;
-        patient: `${ResourceType}/${string}`;
-    };
-    MedicinalProductIndication: {
-        subject: `${ResourceType}/${string}`;
-    };
-    PaymentNotice: {
-        created: date;
-        "payment-status": string;
-        provider: `${ResourceType}/${string}`;
-        status: string;
-        request: `${ResourceType}/${string}`;
-        identifier: string;
-        response: `${ResourceType}/${string}`;
-    };
-    NamingSystem: {
-        "id-type": string;
-        responsible: string;
-        value: string;
-        kind: string;
-        type: string;
-        telecom: string;
-        period: date;
-        contact: string;
-    };
-    MedicationStatement: {
-        "part-of": `${ResourceType}/${string}`;
-        context: `${ResourceType}/${string}`;
-        subject: `${ResourceType}/${string}`;
-        source: `${ResourceType}/${string}`;
-        category: string;
-        effective: date;
-    };
-    EnrollmentResponse: {
-        status: string;
-        request: `${ResourceType}/${string}`;
-        identifier: string;
-    };
-    NutritionOrder: {
-        supplement: string;
-        oraldiet: string;
-        "instantiates-uri": uri;
-        provider: `${ResourceType}/${string}`;
-        status: string;
-        datetime: date;
-        additive: string;
-        "instantiates-canonical": `${ResourceType}/${string}`;
-        formula: string;
-    };
-    Questionnaire: {
-        "context-quantity": string;
-        url: uri;
-        "context-type": string;
-        "subject-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        definition: uri;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        code: string;
-        effective: date;
-        description: string;
-    };
-    Account: {
-        owner: `${ResourceType}/${string}`;
-        name: string;
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        type: string;
-        patient: `${ResourceType}/${string}`;
-        period: date;
-    };
-    EventDefinition: {
-        "context-quantity": string;
-        url: uri;
-        "depends-on": `${ResourceType}/${string}`;
-        "context-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        predecessor: `${ResourceType}/${string}`;
-        "derived-from": `${ResourceType}/${string}`;
-        effective: date;
-        description: string;
-        "composed-of": `${ResourceType}/${string}`;
-        successor: `${ResourceType}/${string}`;
-        topic: string;
-    };
-    MedicinalProductUndesirableEffect: {
-        subject: `${ResourceType}/${string}`;
-    };
-    SubstanceSpecification: {
-        code: string;
-    };
-    CommunicationRequest: {
-        priority: string;
-        "based-on": `${ResourceType}/${string}`;
-        requester: `${ResourceType}/${string}`;
-        recipient: `${ResourceType}/${string}`;
-        authored: date;
-        encounter: `${ResourceType}/${string}`;
-        medium: string;
-        "group-identifier": string;
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        occurrence: date;
-        replaces: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-        category: string;
-        sender: `${ResourceType}/${string}`;
-    };
-    SpecimenDefinition: {
-        identifier: string;
-        type: string;
-        container: string;
-    };
-    VerificationResult: {
-        target: `${ResourceType}/${string}`;
-    };
-    DocumentManifest: {
-        "related-id": string;
-        created: date;
-        author: `${ResourceType}/${string}`;
-        "related-ref": `${ResourceType}/${string}`;
-        recipient: `${ResourceType}/${string}`;
-        status: string;
-        item: `${ResourceType}/${string}`;
-        subject: `${ResourceType}/${string}`;
-        source: uri;
-        description: string;
-    };
-    Task: {
-        owner: `${ResourceType}/${string}`;
-        priority: string;
-        "based-on": `${ResourceType}/${string}`;
-        requester: `${ResourceType}/${string}`;
-        focus: `${ResourceType}/${string}`;
-        encounter: `${ResourceType}/${string}`;
-        "part-of": `${ResourceType}/${string}`;
-        "group-identifier": string;
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        intent: string;
-        modified: date;
-        patient: `${ResourceType}/${string}`;
-        period: date;
-        code: string;
-        performer: string;
-        "authored-on": date;
-        "business-status": string;
-    };
-    RiskEvidenceSynthesis: {
-        "context-quantity": string;
-        url: uri;
-        "context-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        effective: date;
-        description: string;
-    };
-    ValueSet: {
-        expansion: uri;
-        reference: uri;
-        code: string;
-    };
-    Claim: {
-        created: date;
-        priority: string;
-        payee: `${ResourceType}/${string}`;
-        insurer: `${ResourceType}/${string}`;
-        "detail-udi": `${ResourceType}/${string}`;
-        "subdetail-udi": `${ResourceType}/${string}`;
-        encounter: `${ResourceType}/${string}`;
-        provider: `${ResourceType}/${string}`;
-        "procedure-udi": `${ResourceType}/${string}`;
-        "care-team": `${ResourceType}/${string}`;
-        enterer: `${ResourceType}/${string}`;
-        status: string;
-        identifier: string;
-        facility: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-        use: string;
-        "item-udi": `${ResourceType}/${string}`;
-    };
-    InsurancePlan: {
-        "address-use": string;
-        "owned-by": `${ResourceType}/${string}`;
-        "address-country": string;
-        "address-city": string;
-        name: string;
-        "address-state": string;
-        address: string;
-        status: string;
-        identifier: string;
-        type: string;
-        phonetic: string;
-        endpoint: `${ResourceType}/${string}`;
-        "administered-by": `${ResourceType}/${string}`;
-        "address-postalcode": string;
-    };
-    ExampleScenario: {
-        "context-quantity": string;
-        url: uri;
-        "context-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        publisher: string;
-        version: string;
-        date: date;
-    };
-    ResearchStudy: {
-        protocol: `${ResourceType}/${string}`;
-        partof: `${ResourceType}/${string}`;
-        principalinvestigator: `${ResourceType}/${string}`;
-        focus: string;
-        location: string;
-        status: string;
-        identifier: string;
-        keyword: string;
-        sponsor: `${ResourceType}/${string}`;
-        site: `${ResourceType}/${string}`;
-        title: string;
-        date: date;
-        category: string;
-    };
-    MedicationRequest: {
-        "intended-performertype": string;
-        priority: string;
-        requester: `${ResourceType}/${string}`;
-        encounter: `${ResourceType}/${string}`;
-        "intended-performer": `${ResourceType}/${string}`;
-        subject: `${ResourceType}/${string}`;
-        authoredon: date;
-        intent: string;
-        date: date;
-        category: string;
-        "intended-dispenser": `${ResourceType}/${string}`;
-    };
-    Measure: {
-        "context-quantity": string;
-        url: uri;
-        "depends-on": `${ResourceType}/${string}`;
-        "context-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        predecessor: `${ResourceType}/${string}`;
-        "derived-from": `${ResourceType}/${string}`;
-        effective: date;
-        description: string;
-        "composed-of": `${ResourceType}/${string}`;
-        successor: `${ResourceType}/${string}`;
-        topic: string;
-    };
-    List: {
-        status: string;
-        item: `${ResourceType}/${string}`;
-        subject: `${ResourceType}/${string}`;
-        title: string;
-        source: `${ResourceType}/${string}`;
-        notes: string;
-        "empty-reason": string;
-    };
-    Resource: {
-        _source: uri;
-        _lastUpdated: date;
-        _profile: uri;
-        _tag: string;
-        _id: string;
-        _security: string;
-    };
-    Encounter: {
-        "based-on": `${ResourceType}/${string}`;
-        "reason-reference": `${ResourceType}/${string}`;
-        "service-provider": `${ResourceType}/${string}`;
-        class: string;
-        practitioner: `${ResourceType}/${string}`;
-        diagnosis: `${ResourceType}/${string}`;
-        "part-of": `${ResourceType}/${string}`;
-        "special-arrangement": string;
-        location: `${ResourceType}/${string}`;
-        participant: `${ResourceType}/${string}`;
-        "episode-of-care": `${ResourceType}/${string}`;
-        status: string;
-        subject: `${ResourceType}/${string}`;
-        account: `${ResourceType}/${string}`;
-        length: string;
-        appointment: `${ResourceType}/${string}`;
-        "location-period": date;
-        "reason-code": string;
-        "participant-type": string;
-    };
-    CapabilityStatement: {
-        fhirversion: string;
-        resource: string;
-        "supported-profile": `${ResourceType}/${string}`;
-        guide: `${ResourceType}/${string}`;
-        software: string;
-        mode: string;
-        "security-service": string;
-        "resource-profile": `${ResourceType}/${string}`;
-        format: string;
-    };
-    VisionPrescription: {
-        status: string;
-        datewritten: date;
-        prescriber: `${ResourceType}/${string}`;
-    };
-    RiskAssessment: {
-        probability: number;
-        method: string;
-        condition: `${ResourceType}/${string}`;
-        subject: `${ResourceType}/${string}`;
-        risk: string;
-        performer: `${ResourceType}/${string}`;
-    };
-    ImmunizationRecommendation: {
-        "vaccine-type": string;
-        support: `${ResourceType}/${string}`;
-        status: string;
-        identifier: string;
-        "target-disease": string;
-        date: date;
-        information: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-    };
-    RelatedPerson: {
-        relationship: string;
-        name: string;
-        identifier: string;
-        patient: `${ResourceType}/${string}`;
-        active: string;
-    };
-    Medication: {
-        form: string;
-        manufacturer: `${ResourceType}/${string}`;
-        "ingredient-code": string;
-        "expiration-date": date;
-        status: string;
-        identifier: string;
-        ingredient: `${ResourceType}/${string}`;
-        "lot-number": string;
-    };
-    AppointmentResponse: {
-        practitioner: `${ResourceType}/${string}`;
-        location: `${ResourceType}/${string}`;
-        identifier: string;
-        appointment: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-        "part-status": string;
-        actor: `${ResourceType}/${string}`;
-    };
-    ResearchElementDefinition: {
-        "context-quantity": string;
-        url: uri;
-        "depends-on": `${ResourceType}/${string}`;
-        "context-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        predecessor: `${ResourceType}/${string}`;
-        "derived-from": `${ResourceType}/${string}`;
-        effective: date;
-        description: string;
-        "composed-of": `${ResourceType}/${string}`;
-        successor: `${ResourceType}/${string}`;
-        topic: string;
-    };
-    Substance: {
-        "container-identifier": string;
-        "substance-reference": `${ResourceType}/${string}`;
-        quantity: string;
-        status: string;
-        identifier: string;
-        expiry: date;
-        category: string;
-        code: string;
-    };
-    PaymentReconciliation: {
-        created: date;
-        requestor: `${ResourceType}/${string}`;
-        disposition: string;
-        status: string;
-        request: `${ResourceType}/${string}`;
-        identifier: string;
-        "payment-issuer": `${ResourceType}/${string}`;
-        outcome: string;
-    };
-    TestScript: {
-        "context-quantity": string;
-        url: uri;
-        "testscript-capability": string;
-        "context-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        description: string;
-    };
-    ConceptMap: {
-        "source-code": string;
-        "source-uri": `${ResourceType}/${string}`;
-        "target-uri": `${ResourceType}/${string}`;
-        "target-system": uri;
-        dependson: uri;
-        "source-system": uri;
-        product: uri;
-        source: `${ResourceType}/${string}`;
-        other: `${ResourceType}/${string}`;
-        target: `${ResourceType}/${string}`;
-        "target-code": string;
-    };
-    Person: {
-        practitioner: `${ResourceType}/${string}`;
-        relatedperson: `${ResourceType}/${string}`;
-        name: string;
-        identifier: string;
-        link: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-        organization: `${ResourceType}/${string}`;
-    };
-    Condition: {
-        "recorded-date": date;
-        "body-site": string;
-        "onset-age": string;
-        encounter: `${ResourceType}/${string}`;
-        "clinical-status": string;
-        "evidence-detail": `${ResourceType}/${string}`;
-        "abatement-age": string;
-        "abatement-string": string;
-        subject: `${ResourceType}/${string}`;
-        asserter: `${ResourceType}/${string}`;
-        category: string;
-        "onset-date": date;
-        severity: string;
-        "onset-info": string;
-        evidence: string;
-        "verification-status": string;
-        "abatement-date": date;
-        stage: string;
-    };
-    CareTeam: {
-        encounter: `${ResourceType}/${string}`;
-        participant: `${ResourceType}/${string}`;
-        status: string;
-        subject: `${ResourceType}/${string}`;
-        category: string;
-    };
-    StructureDefinition: {
-        abstract: string;
-        experimental: string;
-        path: string;
-        valueset: `${ResourceType}/${string}`;
-        base: `${ResourceType}/${string}`;
-        keyword: string;
-        "ext-context": string;
-        kind: string;
-        type: uri;
-        derivation: string;
-        "base-path": string;
-    };
-    Procedure: {
-        "based-on": `${ResourceType}/${string}`;
-        "reason-reference": `${ResourceType}/${string}`;
-        "instantiates-uri": uri;
-        "part-of": `${ResourceType}/${string}`;
-        location: `${ResourceType}/${string}`;
-        status: string;
-        subject: `${ResourceType}/${string}`;
-        category: string;
-        "instantiates-canonical": `${ResourceType}/${string}`;
-        "reason-code": string;
-        performer: `${ResourceType}/${string}`;
-    };
-    Consent: {
-        "security-label": string;
-        consentor: `${ResourceType}/${string}`;
-        status: string;
-        scope: string;
-        action: string;
-        category: string;
-        period: date;
-        "source-reference": `${ResourceType}/${string}`;
-        data: `${ResourceType}/${string}`;
-        organization: `${ResourceType}/${string}`;
-        actor: `${ResourceType}/${string}`;
-        purpose: string;
-    };
-    Location: {
-        "address-use": string;
-        partof: `${ResourceType}/${string}`;
-        "address-country": string;
-        "operational-status": string;
-        "address-city": string;
-        name: string;
-        "address-state": string;
-        address: string;
-        status: string;
-        identifier: string;
-        type: string;
-        endpoint: `${ResourceType}/${string}`;
-        organization: `${ResourceType}/${string}`;
-        "address-postalcode": string;
-        near: string;
-    };
-    Organization: {
-        "address-use": string;
-        partof: `${ResourceType}/${string}`;
-        "address-country": string;
-        "address-city": string;
-        name: string;
-        "address-state": string;
-        address: string;
-        identifier: string;
-        type: string;
-        phonetic: string;
-        endpoint: `${ResourceType}/${string}`;
-        active: string;
-        "address-postalcode": string;
-    };
-    Device: {
-        url: uri;
-        model: string;
-        "device-name": string;
-        manufacturer: string;
-        location: `${ResourceType}/${string}`;
-        status: string;
-        identifier: string;
-        din: string;
-        "udi-carrier": string;
-        type: string;
-        patient: `${ResourceType}/${string}`;
-        "udi-di": string;
-        organization: `${ResourceType}/${string}`;
-    };
-    SupplyRequest: {
-        requester: `${ResourceType}/${string}`;
-        status: string;
-        subject: `${ResourceType}/${string}`;
-        supplier: `${ResourceType}/${string}`;
-        category: string;
-    };
-    AllergyIntolerance: {
-        onset: date;
-        "last-date": date;
-        route: string;
-        "clinical-status": string;
-        criticality: string;
-        recorder: `${ResourceType}/${string}`;
-        asserter: `${ResourceType}/${string}`;
-        type: string;
-        category: string;
-        severity: string;
-        manifestation: string;
-        "verification-status": string;
-    };
-    SearchParameter: {
-        component: `${ResourceType}/${string}`;
-        base: string;
-        type: string;
-        target: string;
-        code: string;
-        "derived-from": `${ResourceType}/${string}`;
-    };
-    ResearchDefinition: {
-        "context-quantity": string;
-        url: uri;
-        "depends-on": `${ResourceType}/${string}`;
-        "context-type": string;
-        name: string;
-        context: string;
-        status: string;
-        identifier: string;
-        jurisdiction: string;
-        title: string;
-        publisher: string;
-        version: string;
-        date: date;
-        predecessor: `${ResourceType}/${string}`;
-        "derived-from": `${ResourceType}/${string}`;
-        effective: date;
-        description: string;
-        "composed-of": `${ResourceType}/${string}`;
-        successor: `${ResourceType}/${string}`;
-        topic: string;
-    };
-    OperationDefinition: {
-        base: `${ResourceType}/${string}`;
-        "input-profile": `${ResourceType}/${string}`;
-        instance: string;
-        kind: string;
-        type: string;
-        "output-profile": `${ResourceType}/${string}`;
-        system: string;
-        code: string;
-    };
-    ImagingStudy: {
-        started: date;
-        referrer: `${ResourceType}/${string}`;
-        encounter: `${ResourceType}/${string}`;
-        modality: string;
-        status: string;
-        subject: `${ResourceType}/${string}`;
-        instance: string;
-        bodysite: string;
-        "dicom-class": string;
-        series: string;
-        interpreter: `${ResourceType}/${string}`;
-        reason: string;
-        endpoint: `${ResourceType}/${string}`;
-        basedon: `${ResourceType}/${string}`;
-        performer: `${ResourceType}/${string}`;
-    };
-    CoverageEligibilityRequest: {
-        created: date;
-        provider: `${ResourceType}/${string}`;
-        enterer: `${ResourceType}/${string}`;
-        status: string;
-        identifier: string;
-        facility: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-    };
-    GuidanceResponse: {
-        request: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        patient: `${ResourceType}/${string}`;
-    };
-    Media: {
-        created: date;
-        device: `${ResourceType}/${string}`;
-        "based-on": `${ResourceType}/${string}`;
-        operator: `${ResourceType}/${string}`;
-        encounter: `${ResourceType}/${string}`;
-        modality: string;
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        site: string;
-        type: string;
-        patient: `${ResourceType}/${string}`;
-        view: string;
-    };
-    MeasureReport: {
-        "evaluated-resource": `${ResourceType}/${string}`;
-        reporter: `${ResourceType}/${string}`;
-        measure: `${ResourceType}/${string}`;
-        status: string;
-        identifier: string;
-        subject: `${ResourceType}/${string}`;
-        date: date;
-        patient: `${ResourceType}/${string}`;
-        period: date;
-    };
-    GraphDefinition: {
-        start: string;
-    };
-}
diff --git a/vendor/r4/types/hl7-fhir-r4-core/index.js b/vendor/r4/types/hl7-fhir-r4-core/index.js
index 38f1da4..c8ad2e5 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/index.js
+++ b/vendor/r4/types/hl7-fhir-r4-core/index.js
@@ -1,226 +1,2 @@
 "use strict";
-/** GENERATED BY zen-cli
-DON'T MODIFY MANUALLY */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ImmunizationEvaluation"), exports);
-__exportStar(require("./Appointment"), exports);
-__exportStar(require("./StructureMap"), exports);
-__exportStar(require("./Address"), exports);
-__exportStar(require("./CareTeam"), exports);
-__exportStar(require("./UsageContext"), exports);
-__exportStar(require("./Linkage"), exports);
-__exportStar(require("./Annotation"), exports);
-__exportStar(require("./Age"), exports);
-__exportStar(require("./Attachment"), exports);
-__exportStar(require("./positiveInt"), exports);
-__exportStar(require("./unsignedInt"), exports);
-__exportStar(require("./Communication"), exports);
-__exportStar(require("./MedicationDispense"), exports);
-__exportStar(require("./ImagingStudy"), exports);
-__exportStar(require("./ChargeItem"), exports);
-__exportStar(require("./Period"), exports);
-__exportStar(require("./AdverseEvent"), exports);
-__exportStar(require("./url"), exports);
-__exportStar(require("./ContactDetail"), exports);
-__exportStar(require("./DataRequirement"), exports);
-__exportStar(require("./Media"), exports);
-__exportStar(require("./CodeableConcept"), exports);
-__exportStar(require("./SubstancePolymer"), exports);
-__exportStar(require("./QuestionnaireResponse"), exports);
-__exportStar(require("./Coverage"), exports);
-__exportStar(require("./Procedure"), exports);
-__exportStar(require("./AuditEvent"), exports);
-__exportStar(require("./PaymentReconciliation"), exports);
-__exportStar(require("./MedicinalProductManufactured"), exports);
-__exportStar(require("./CompartmentDefinition"), exports);
-__exportStar(require("./Organization"), exports);
-__exportStar(require("./ExplanationOfBenefit"), exports);
-__exportStar(require("./Composition"), exports);
-__exportStar(require("./SimpleQuantity"), exports);
-__exportStar(require("./CoverageEligibilityResponse"), exports);
-__exportStar(require("./DocumentReference"), exports);
-__exportStar(require("./EventDefinition"), exports);
-__exportStar(require("./SubstanceProtein"), exports);
-__exportStar(require("./TerminologyCapabilities"), exports);
-__exportStar(require("./Encounter"), exports);
-__exportStar(require("./ImplementationGuide"), exports);
-__exportStar(require("./EvidenceVariable"), exports);
-__exportStar(require("./ObservationDefinition"), exports);
-__exportStar(require("./DiagnosticReport"), exports);
-__exportStar(require("./ExampleScenario"), exports);
-__exportStar(require("./ResearchDefinition"), exports);
-__exportStar(require("./Parameters"), exports);
-__exportStar(require("./SearchParameter"), exports);
-__exportStar(require("./MedicinalProductInteraction"), exports);
-__exportStar(require("./CodeSystem"), exports);
-__exportStar(require("./MessageDefinition"), exports);
-__exportStar(require("./NutritionOrder"), exports);
-__exportStar(require("./xhtml"), exports);
-__exportStar(require("./VerificationResult"), exports);
-__exportStar(require("./MedicationAdministration"), exports);
-__exportStar(require("./CatalogEntry"), exports);
-__exportStar(require("./Flag"), exports);
-__exportStar(require("./DeviceUseStatement"), exports);
-__exportStar(require("./TriggerDefinition"), exports);
-__exportStar(require("./uri"), exports);
-__exportStar(require("./Contract"), exports);
-__exportStar(require("./Invoice"), exports);
-__exportStar(require("./MarketingStatus"), exports);
-__exportStar(require("./Count"), exports);
-__exportStar(require("./PaymentNotice"), exports);
-__exportStar(require("./Location"), exports);
-__exportStar(require("./Claim"), exports);
-__exportStar(require("./Specimen"), exports);
-__exportStar(require("./MedicationStatement"), exports);
-__exportStar(require("./EnrollmentResponse"), exports);
-__exportStar(require("./Evidence"), exports);
-__exportStar(require("./Bundle"), exports);
-__exportStar(require("./ResearchElementDefinition"), exports);
-__exportStar(require("./Expression"), exports);
-__exportStar(require("./Coding"), exports);
-__exportStar(require("./BodyStructure"), exports);
-__exportStar(require("./id"), exports);
-__exportStar(require("./MedicinalProduct"), exports);
-__exportStar(require("./dateTime"), exports);
-__exportStar(require("./ResearchStudy"), exports);
-__exportStar(require("./Dosage"), exports);
-__exportStar(require("./AppointmentResponse"), exports);
-__exportStar(require("./MedicinalProductIndication"), exports);
-__exportStar(require("./Measure"), exports);
-__exportStar(require("./Person"), exports);
-__exportStar(require("./InsurancePlan"), exports);
-__exportStar(require("./Patient"), exports);
-__exportStar(require("./EffectEvidenceSynthesis"), exports);
-__exportStar(require("./ResearchSubject"), exports);
-__exportStar(require("./Medication"), exports);
-__exportStar(require("./Range"), exports);
-__exportStar(require("./ConceptMap"), exports);
-__exportStar(require("./CoverageEligibilityRequest"), exports);
-__exportStar(require("./Population"), exports);
-__exportStar(require("./SubstanceSourceMaterial"), exports);
-__exportStar(require("./VisionPrescription"), exports);
-__exportStar(require("./oid"), exports);
-__exportStar(require("./MolecularSequence"), exports);
-__exportStar(require("./MedicinalProductUndesirableEffect"), exports);
-__exportStar(require("./OperationOutcome"), exports);
-__exportStar(require("./MessageHeader"), exports);
-__exportStar(require("./ContactPoint"), exports);
-__exportStar(require("./uuid"), exports);
-__exportStar(require("./Signature"), exports);
-__exportStar(require("./AllergyIntolerance"), exports);
-__exportStar(require("./SubstanceReferenceInformation"), exports);
-__exportStar(require("./SupplyDelivery"), exports);
-__exportStar(require("./EpisodeOfCare"), exports);
-__exportStar(require("./PractitionerRole"), exports);
-__exportStar(require("./Library"), exports);
-__exportStar(require("./Practitioner"), exports);
-__exportStar(require("./MedicationRequest"), exports);
-__exportStar(require("./ImmunizationRecommendation"), exports);
-__exportStar(require("./RelatedArtifact"), exports);
-__exportStar(require("./Timing"), exports);
-__exportStar(require("./Immunization"), exports);
-__exportStar(require("./GraphDefinition"), exports);
-__exportStar(require("./Account"), exports);
-__exportStar(require("./MedicinalProductIngredient"), exports);
-__exportStar(require("./ProdCharacteristic"), exports);
-__exportStar(require("./Meta"), exports);
-__exportStar(require("./Quantity"), exports);
-__exportStar(require("./MeasureReport"), exports);
-__exportStar(require("./Distance"), exports);
-__exportStar(require("./canonical"), exports);
-__exportStar(require("./HumanName"), exports);
-__exportStar(require("./DeviceMetric"), exports);
-__exportStar(require("./Duration"), exports);
-__exportStar(require("./SubstanceAmount"), exports);
-__exportStar(require("./Goal"), exports);
-__exportStar(require("./time"), exports);
-__exportStar(require("./MedicationKnowledge"), exports);
-__exportStar(require("./ClaimResponse"), exports);
-__exportStar(require("./DeviceDefinition"), exports);
-__exportStar(require("./Slot"), exports);
-__exportStar(require("./ValueSet"), exports);
-__exportStar(require("./MedicinalProductAuthorization"), exports);
-__exportStar(require("./StructureDefinition"), exports);
-__exportStar(require("./integer"), exports);
-__exportStar(require("./MedicinalProductContraindication"), exports);
-__exportStar(require("./ElementDefinition"), exports);
-__exportStar(require("./DeviceRequest"), exports);
-__exportStar(require("./List"), exports);
-__exportStar(require("./Questionnaire"), exports);
-__exportStar(require("./DomainResource"), exports);
-__exportStar(require("./Endpoint"), exports);
-__exportStar(require("./NamingSystem"), exports);
-__exportStar(require("./MedicinalProductPackaged"), exports);
-__exportStar(require("./Basic"), exports);
-__exportStar(require("./Money"), exports);
-__exportStar(require("./Binary"), exports);
-__exportStar(require("./PlanDefinition"), exports);
-__exportStar(require("./Subscription"), exports);
-__exportStar(require("./SampledData"), exports);
-__exportStar(require("./ProductShelfLife"), exports);
-__exportStar(require("./RelatedPerson"), exports);
-__exportStar(require("./SubstanceSpecification"), exports);
-__exportStar(require("./date"), exports);
-__exportStar(require("./Ratio"), exports);
-__exportStar(require("./markdown"), exports);
-__exportStar(require("./SubstanceNucleicAcid"), exports);
-__exportStar(require("./GuidanceResponse"), exports);
-__exportStar(require("./ClinicalImpression"), exports);
-__exportStar(require("./OrganizationAffiliation"), exports);
-__exportStar(require("./Resource"), exports);
-__exportStar(require("./Condition"), exports);
-__exportStar(require("./Extension"), exports);
-__exportStar(require("./CapabilityStatement"), exports);
-__exportStar(require("./HealthcareService"), exports);
-__exportStar(require("./SpecimenDefinition"), exports);
-__exportStar(require("./ParameterDefinition"), exports);
-__exportStar(require("./RiskAssessment"), exports);
-__exportStar(require("./OperationDefinition"), exports);
-__exportStar(require("./ActivityDefinition"), exports);
-__exportStar(require("./Schedule"), exports);
-__exportStar(require("./BiologicallyDerivedProduct"), exports);
-__exportStar(require("./Group"), exports);
-__exportStar(require("./MedicinalProductPharmaceutical"), exports);
-__exportStar(require("./base64Binary"), exports);
-__exportStar(require("./FamilyMemberHistory"), exports);
-__exportStar(require("./ServiceRequest"), exports);
-__exportStar(require("./DetectedIssue"), exports);
-__exportStar(require("./instant"), exports);
-__exportStar(require("./Device"), exports);
-__exportStar(require("./RequestGroup"), exports);
-__exportStar(require("./TestScript"), exports);
-__exportStar(require("./RiskEvidenceSynthesis"), exports);
-__exportStar(require("./SupplyRequest"), exports);
-__exportStar(require("./Element"), exports);
-__exportStar(require("./Reference"), exports);
-__exportStar(require("./code"), exports);
-__exportStar(require("./Task"), exports);
-__exportStar(require("./Identifier"), exports);
-__exportStar(require("./CommunicationRequest"), exports);
-__exportStar(require("./EnrollmentRequest"), exports);
-__exportStar(require("./ChargeItemDefinition"), exports);
-__exportStar(require("./Substance"), exports);
-__exportStar(require("./Provenance"), exports);
-__exportStar(require("./Consent"), exports);
-__exportStar(require("./BackboneElement"), exports);
-__exportStar(require("./CarePlan"), exports);
-__exportStar(require("./Narrative"), exports);
-__exportStar(require("./decimal"), exports);
-__exportStar(require("./TestReport"), exports);
-__exportStar(require("./Observation"), exports);
-__exportStar(require("./DocumentManifest"), exports);
-__exportStar(require("./Contributor"), exports);
diff --git a/vendor/r4/types/hl7-fhir-r4-core/indexPackage.d.ts b/vendor/r4/types/hl7-fhir-r4-core/indexPackage.d.ts
new file mode 100644
index 0000000..3d0cd1f
--- /dev/null
+++ b/vendor/r4/types/hl7-fhir-r4-core/indexPackage.d.ts
@@ -0,0 +1,527 @@
+/** GENERATED BY zen-cli
+DON'T MODIFY MANUALLY */
+export * from './ImmunizationEvaluation';
+export * from './Appointment';
+export * from './StructureMap';
+export * from './Address';
+export * from './CareTeam';
+export * from './UsageContext';
+export * from './Linkage';
+export * from './Annotation';
+export * from './Age';
+export * from './Attachment';
+export * from './positiveInt';
+export * from './unsignedInt';
+export * from './Communication';
+export * from './MedicationDispense';
+export * from './ImagingStudy';
+export * from './ChargeItem';
+export * from './Period';
+export * from './AdverseEvent';
+export * from './url';
+export * from './ContactDetail';
+export * from './DataRequirement';
+export * from './Media';
+export * from './CodeableConcept';
+export * from './SubstancePolymer';
+export * from './QuestionnaireResponse';
+export * from './Coverage';
+export * from './Procedure';
+export * from './AuditEvent';
+export * from './PaymentReconciliation';
+export * from './MedicinalProductManufactured';
+export * from './CompartmentDefinition';
+export * from './Organization';
+export * from './ExplanationOfBenefit';
+export * from './Composition';
+export * from './SimpleQuantity';
+export * from './CoverageEligibilityResponse';
+export * from './DocumentReference';
+export * from './EventDefinition';
+export * from './SubstanceProtein';
+export * from './TerminologyCapabilities';
+export * from './Encounter';
+export * from './ImplementationGuide';
+export * from './EvidenceVariable';
+export * from './ObservationDefinition';
+export * from './DiagnosticReport';
+export * from './ExampleScenario';
+export * from './ResearchDefinition';
+export * from './Parameters';
+export * from './SearchParameter';
+export * from './MedicinalProductInteraction';
+export * from './CodeSystem';
+export * from './MessageDefinition';
+export * from './NutritionOrder';
+export * from './xhtml';
+export * from './VerificationResult';
+export * from './MedicationAdministration';
+export * from './CatalogEntry';
+export * from './Flag';
+export * from './DeviceUseStatement';
+export * from './TriggerDefinition';
+export * from './uri';
+export * from './Contract';
+export * from './Invoice';
+export * from './MarketingStatus';
+export * from './Count';
+export * from './PaymentNotice';
+export * from './Location';
+export * from './Claim';
+export * from './Specimen';
+export * from './MedicationStatement';
+export * from './EnrollmentResponse';
+export * from './Evidence';
+export * from './Bundle';
+export * from './ResearchElementDefinition';
+export * from './Expression';
+export * from './Coding';
+export * from './BodyStructure';
+export * from './id';
+export * from './MedicinalProduct';
+export * from './dateTime';
+export * from './ResearchStudy';
+export * from './Dosage';
+export * from './AppointmentResponse';
+export * from './MedicinalProductIndication';
+export * from './Measure';
+export * from './Person';
+export * from './InsurancePlan';
+export * from './Patient';
+export * from './EffectEvidenceSynthesis';
+export * from './ResearchSubject';
+export * from './Medication';
+export * from './Range';
+export * from './ConceptMap';
+export * from './CoverageEligibilityRequest';
+export * from './Population';
+export * from './SubstanceSourceMaterial';
+export * from './VisionPrescription';
+export * from './oid';
+export * from './MolecularSequence';
+export * from './MedicinalProductUndesirableEffect';
+export * from './OperationOutcome';
+export * from './MessageHeader';
+export * from './ContactPoint';
+export * from './uuid';
+export * from './Signature';
+export * from './AllergyIntolerance';
+export * from './SubstanceReferenceInformation';
+export * from './SupplyDelivery';
+export * from './EpisodeOfCare';
+export * from './PractitionerRole';
+export * from './Library';
+export * from './Practitioner';
+export * from './MedicationRequest';
+export * from './ImmunizationRecommendation';
+export * from './RelatedArtifact';
+export * from './Timing';
+export * from './Immunization';
+export * from './GraphDefinition';
+export * from './Account';
+export * from './MedicinalProductIngredient';
+export * from './ProdCharacteristic';
+export * from './Meta';
+export * from './Quantity';
+export * from './MeasureReport';
+export * from './Distance';
+export * from './canonical';
+export * from './HumanName';
+export * from './DeviceMetric';
+export * from './Duration';
+export * from './SubstanceAmount';
+export * from './Goal';
+export * from './time';
+export * from './MedicationKnowledge';
+export * from './ClaimResponse';
+export * from './DeviceDefinition';
+export * from './Slot';
+export * from './ValueSet';
+export * from './MedicinalProductAuthorization';
+export * from './StructureDefinition';
+export * from './integer';
+export * from './MedicinalProductContraindication';
+export * from './ElementDefinition';
+export * from './DeviceRequest';
+export * from './List';
+export * from './Questionnaire';
+export * from './DomainResource';
+export * from './Endpoint';
+export * from './NamingSystem';
+export * from './MedicinalProductPackaged';
+export * from './Basic';
+export * from './Money';
+export * from './Binary';
+export * from './PlanDefinition';
+export * from './Subscription';
+export * from './SampledData';
+export * from './ProductShelfLife';
+export * from './RelatedPerson';
+export * from './SubstanceSpecification';
+export * from './date';
+export * from './Ratio';
+export * from './markdown';
+export * from './SubstanceNucleicAcid';
+export * from './GuidanceResponse';
+export * from './ClinicalImpression';
+export * from './OrganizationAffiliation';
+export * from './Resource';
+export * from './Condition';
+export * from './Extension';
+export * from './CapabilityStatement';
+export * from './HealthcareService';
+export * from './SpecimenDefinition';
+export * from './ParameterDefinition';
+export * from './RiskAssessment';
+export * from './OperationDefinition';
+export * from './ActivityDefinition';
+export * from './Schedule';
+export * from './BiologicallyDerivedProduct';
+export * from './Group';
+export * from './MedicinalProductPharmaceutical';
+export * from './base64Binary';
+export * from './FamilyMemberHistory';
+export * from './ServiceRequest';
+export * from './DetectedIssue';
+export * from './instant';
+export * from './Device';
+export * from './RequestGroup';
+export * from './TestScript';
+export * from './RiskEvidenceSynthesis';
+export * from './SupplyRequest';
+export * from './Element';
+export * from './Reference';
+export * from './code';
+export * from './Task';
+export * from './Identifier';
+export * from './CommunicationRequest';
+export * from './EnrollmentRequest';
+export * from './ChargeItemDefinition';
+export * from './Substance';
+export * from './Provenance';
+export * from './Consent';
+export * from './BackboneElement';
+export * from './CarePlan';
+export * from './Narrative';
+export * from './decimal';
+export * from './TestReport';
+export * from './Observation';
+export * from './DocumentManifest';
+export * from './Contributor';
+import { ImmunizationEvaluation } from './ImmunizationEvaluation';
+import { Appointment } from './Appointment';
+import { StructureMap } from './StructureMap';
+import { CareTeam } from './CareTeam';
+import { Linkage } from './Linkage';
+import { Communication } from './Communication';
+import { MedicationDispense } from './MedicationDispense';
+import { ImagingStudy } from './ImagingStudy';
+import { ChargeItem } from './ChargeItem';
+import { AdverseEvent } from './AdverseEvent';
+import { Media } from './Media';
+import { SubstancePolymer } from './SubstancePolymer';
+import { QuestionnaireResponse } from './QuestionnaireResponse';
+import { Coverage } from './Coverage';
+import { Procedure } from './Procedure';
+import { AuditEvent } from './AuditEvent';
+import { PaymentReconciliation } from './PaymentReconciliation';
+import { MedicinalProductManufactured } from './MedicinalProductManufactured';
+import { CompartmentDefinition } from './CompartmentDefinition';
+import { Organization } from './Organization';
+import { ExplanationOfBenefit } from './ExplanationOfBenefit';
+import { Composition } from './Composition';
+import { CoverageEligibilityResponse } from './CoverageEligibilityResponse';
+import { DocumentReference } from './DocumentReference';
+import { EventDefinition } from './EventDefinition';
+import { SubstanceProtein } from './SubstanceProtein';
+import { TerminologyCapabilities } from './TerminologyCapabilities';
+import { Encounter } from './Encounter';
+import { ImplementationGuide } from './ImplementationGuide';
+import { EvidenceVariable } from './EvidenceVariable';
+import { ObservationDefinition } from './ObservationDefinition';
+import { DiagnosticReport } from './DiagnosticReport';
+import { ExampleScenario } from './ExampleScenario';
+import { ResearchDefinition } from './ResearchDefinition';
+import { Parameters } from './Parameters';
+import { SearchParameter } from './SearchParameter';
+import { MedicinalProductInteraction } from './MedicinalProductInteraction';
+import { CodeSystem } from './CodeSystem';
+import { MessageDefinition } from './MessageDefinition';
+import { NutritionOrder } from './NutritionOrder';
+import { VerificationResult } from './VerificationResult';
+import { MedicationAdministration } from './MedicationAdministration';
+import { CatalogEntry } from './CatalogEntry';
+import { Flag } from './Flag';
+import { DeviceUseStatement } from './DeviceUseStatement';
+import { Contract } from './Contract';
+import { Invoice } from './Invoice';
+import { PaymentNotice } from './PaymentNotice';
+import { Location } from './Location';
+import { Claim } from './Claim';
+import { Specimen } from './Specimen';
+import { MedicationStatement } from './MedicationStatement';
+import { EnrollmentResponse } from './EnrollmentResponse';
+import { Evidence } from './Evidence';
+import { Bundle } from './Bundle';
+import { ResearchElementDefinition } from './ResearchElementDefinition';
+import { BodyStructure } from './BodyStructure';
+import { MedicinalProduct } from './MedicinalProduct';
+import { ResearchStudy } from './ResearchStudy';
+import { AppointmentResponse } from './AppointmentResponse';
+import { MedicinalProductIndication } from './MedicinalProductIndication';
+import { Measure } from './Measure';
+import { Person } from './Person';
+import { InsurancePlan } from './InsurancePlan';
+import { Patient } from './Patient';
+import { EffectEvidenceSynthesis } from './EffectEvidenceSynthesis';
+import { ResearchSubject } from './ResearchSubject';
+import { Medication } from './Medication';
+import { ConceptMap } from './ConceptMap';
+import { CoverageEligibilityRequest } from './CoverageEligibilityRequest';
+import { SubstanceSourceMaterial } from './SubstanceSourceMaterial';
+import { VisionPrescription } from './VisionPrescription';
+import { MolecularSequence } from './MolecularSequence';
+import { MedicinalProductUndesirableEffect } from './MedicinalProductUndesirableEffect';
+import { OperationOutcome } from './OperationOutcome';
+import { MessageHeader } from './MessageHeader';
+import { AllergyIntolerance } from './AllergyIntolerance';
+import { SubstanceReferenceInformation } from './SubstanceReferenceInformation';
+import { SupplyDelivery } from './SupplyDelivery';
+import { EpisodeOfCare } from './EpisodeOfCare';
+import { PractitionerRole } from './PractitionerRole';
+import { Library } from './Library';
+import { Practitioner } from './Practitioner';
+import { MedicationRequest } from './MedicationRequest';
+import { ImmunizationRecommendation } from './ImmunizationRecommendation';
+import { Immunization } from './Immunization';
+import { GraphDefinition } from './GraphDefinition';
+import { Account } from './Account';
+import { MedicinalProductIngredient } from './MedicinalProductIngredient';
+import { MeasureReport } from './MeasureReport';
+import { DeviceMetric } from './DeviceMetric';
+import { Goal } from './Goal';
+import { MedicationKnowledge } from './MedicationKnowledge';
+import { ClaimResponse } from './ClaimResponse';
+import { DeviceDefinition } from './DeviceDefinition';
+import { Slot } from './Slot';
+import { ValueSet } from './ValueSet';
+import { MedicinalProductAuthorization } from './MedicinalProductAuthorization';
+import { StructureDefinition } from './StructureDefinition';
+import { MedicinalProductContraindication } from './MedicinalProductContraindication';
+import { DeviceRequest } from './DeviceRequest';
+import { List } from './List';
+import { Questionnaire } from './Questionnaire';
+import { Endpoint } from './Endpoint';
+import { NamingSystem } from './NamingSystem';
+import { MedicinalProductPackaged } from './MedicinalProductPackaged';
+import { Basic } from './Basic';
+import { Binary } from './Binary';
+import { PlanDefinition } from './PlanDefinition';
+import { Subscription } from './Subscription';
+import { RelatedPerson } from './RelatedPerson';
+import { SubstanceSpecification } from './SubstanceSpecification';
+import { SubstanceNucleicAcid } from './SubstanceNucleicAcid';
+import { GuidanceResponse } from './GuidanceResponse';
+import { ClinicalImpression } from './ClinicalImpression';
+import { OrganizationAffiliation } from './OrganizationAffiliation';
+import { Condition } from './Condition';
+import { CapabilityStatement } from './CapabilityStatement';
+import { HealthcareService } from './HealthcareService';
+import { SpecimenDefinition } from './SpecimenDefinition';
+import { RiskAssessment } from './RiskAssessment';
+import { OperationDefinition } from './OperationDefinition';
+import { ActivityDefinition } from './ActivityDefinition';
+import { Schedule } from './Schedule';
+import { BiologicallyDerivedProduct } from './BiologicallyDerivedProduct';
+import { Group } from './Group';
+import { MedicinalProductPharmaceutical } from './MedicinalProductPharmaceutical';
+import { FamilyMemberHistory } from './FamilyMemberHistory';
+import { ServiceRequest } from './ServiceRequest';
+import { DetectedIssue } from './DetectedIssue';
+import { Device } from './Device';
+import { RequestGroup } from './RequestGroup';
+import { TestScript } from './TestScript';
+import { RiskEvidenceSynthesis } from './RiskEvidenceSynthesis';
+import { SupplyRequest } from './SupplyRequest';
+import { Task } from './Task';
+import { CommunicationRequest } from './CommunicationRequest';
+import { EnrollmentRequest } from './EnrollmentRequest';
+import { ChargeItemDefinition } from './ChargeItemDefinition';
+import { Substance } from './Substance';
+import { Provenance } from './Provenance';
+import { Consent } from './Consent';
+import { CarePlan } from './CarePlan';
+import { TestReport } from './TestReport';
+import { Observation } from './Observation';
+import { DocumentManifest } from './DocumentManifest';
+export interface SubsSubscription {
+    id?: string;
+    resourceType: 'SubsSubscription';
+    status: 'active' | 'off';
+    trigger: Partial<Record<ResourceType, {
+        event: Array<'all' | 'create' | 'update' | 'delete'>;
+        filter?: unknown;
+    }>>;
+    channel: {
+        type: 'rest-hook';
+        endpoint: string;
+        payload?: {
+            content: string;
+            contentType: string;
+            context: unknown;
+        };
+        headers?: Record<string, string>;
+        timeout?: number;
+    };
+}
+export type ResourceTypeMap = {
+    SubsSubscription: SubsSubscription;
+    User: Record<string, any>;
+    ImmunizationEvaluation: ImmunizationEvaluation;
+    Appointment: Appointment;
+    StructureMap: StructureMap;
+    CareTeam: CareTeam;
+    Linkage: Linkage;
+    Communication: Communication;
+    MedicationDispense: MedicationDispense;
+    ImagingStudy: ImagingStudy;
+    ChargeItem: ChargeItem;
+    AdverseEvent: AdverseEvent;
+    Media: Media;
+    SubstancePolymer: SubstancePolymer;
+    QuestionnaireResponse: QuestionnaireResponse;
+    Coverage: Coverage;
+    Procedure: Procedure;
+    AuditEvent: AuditEvent;
+    PaymentReconciliation: PaymentReconciliation;
+    MedicinalProductManufactured: MedicinalProductManufactured;
+    CompartmentDefinition: CompartmentDefinition;
+    Organization: Organization;
+    ExplanationOfBenefit: ExplanationOfBenefit;
+    Composition: Composition;
+    CoverageEligibilityResponse: CoverageEligibilityResponse;
+    DocumentReference: DocumentReference;
+    EventDefinition: EventDefinition;
+    SubstanceProtein: SubstanceProtein;
+    TerminologyCapabilities: TerminologyCapabilities;
+    Encounter: Encounter;
+    ImplementationGuide: ImplementationGuide;
+    EvidenceVariable: EvidenceVariable;
+    ObservationDefinition: ObservationDefinition;
+    DiagnosticReport: DiagnosticReport;
+    ExampleScenario: ExampleScenario;
+    ResearchDefinition: ResearchDefinition;
+    Parameters: Parameters;
+    SearchParameter: SearchParameter;
+    MedicinalProductInteraction: MedicinalProductInteraction;
+    CodeSystem: CodeSystem;
+    MessageDefinition: MessageDefinition;
+    NutritionOrder: NutritionOrder;
+    VerificationResult: VerificationResult;
+    MedicationAdministration: MedicationAdministration;
+    CatalogEntry: CatalogEntry;
+    Flag: Flag;
+    DeviceUseStatement: DeviceUseStatement;
+    Contract: Contract;
+    Invoice: Invoice;
+    PaymentNotice: PaymentNotice;
+    Location: Location;
+    Claim: Claim;
+    Specimen: Specimen;
+    MedicationStatement: MedicationStatement;
+    EnrollmentResponse: EnrollmentResponse;
+    Evidence: Evidence;
+    Bundle: Bundle;
+    ResearchElementDefinition: ResearchElementDefinition;
+    BodyStructure: BodyStructure;
+    MedicinalProduct: MedicinalProduct;
+    ResearchStudy: ResearchStudy;
+    AppointmentResponse: AppointmentResponse;
+    MedicinalProductIndication: MedicinalProductIndication;
+    Measure: Measure;
+    Person: Person;
+    InsurancePlan: InsurancePlan;
+    Patient: Patient;
+    EffectEvidenceSynthesis: EffectEvidenceSynthesis;
+    ResearchSubject: ResearchSubject;
+    Medication: Medication;
+    ConceptMap: ConceptMap;
+    CoverageEligibilityRequest: CoverageEligibilityRequest;
+    SubstanceSourceMaterial: SubstanceSourceMaterial;
+    VisionPrescription: VisionPrescription;
+    MolecularSequence: MolecularSequence;
+    MedicinalProductUndesirableEffect: MedicinalProductUndesirableEffect;
+    OperationOutcome: OperationOutcome;
+    MessageHeader: MessageHeader;
+    AllergyIntolerance: AllergyIntolerance;
+    SubstanceReferenceInformation: SubstanceReferenceInformation;
+    SupplyDelivery: SupplyDelivery;
+    EpisodeOfCare: EpisodeOfCare;
+    PractitionerRole: PractitionerRole;
+    Library: Library;
+    Practitioner: Practitioner;
+    MedicationRequest: MedicationRequest;
+    ImmunizationRecommendation: ImmunizationRecommendation;
+    Immunization: Immunization;
+    GraphDefinition: GraphDefinition;
+    Account: Account;
+    MedicinalProductIngredient: MedicinalProductIngredient;
+    MeasureReport: MeasureReport;
+    DeviceMetric: DeviceMetric;
+    Goal: Goal;
+    MedicationKnowledge: MedicationKnowledge;
+    ClaimResponse: ClaimResponse;
+    DeviceDefinition: DeviceDefinition;
+    Slot: Slot;
+    ValueSet: ValueSet;
+    MedicinalProductAuthorization: MedicinalProductAuthorization;
+    StructureDefinition: StructureDefinition;
+    MedicinalProductContraindication: MedicinalProductContraindication;
+    DeviceRequest: DeviceRequest;
+    List: List;
+    Questionnaire: Questionnaire;
+    Endpoint: Endpoint;
+    NamingSystem: NamingSystem;
+    MedicinalProductPackaged: MedicinalProductPackaged;
+    Basic: Basic;
+    Binary: Binary;
+    PlanDefinition: PlanDefinition;
+    Subscription: Subscription;
+    RelatedPerson: RelatedPerson;
+    SubstanceSpecification: SubstanceSpecification;
+    SubstanceNucleicAcid: SubstanceNucleicAcid;
+    GuidanceResponse: GuidanceResponse;
+    ClinicalImpression: ClinicalImpression;
+    OrganizationAffiliation: OrganizationAffiliation;
+    Condition: Condition;
+    CapabilityStatement: CapabilityStatement;
+    HealthcareService: HealthcareService;
+    SpecimenDefinition: SpecimenDefinition;
+    RiskAssessment: RiskAssessment;
+    OperationDefinition: OperationDefinition;
+    ActivityDefinition: ActivityDefinition;
+    Schedule: Schedule;
+    BiologicallyDerivedProduct: BiologicallyDerivedProduct;
+    Group: Group;
+    MedicinalProductPharmaceutical: MedicinalProductPharmaceutical;
+    FamilyMemberHistory: FamilyMemberHistory;
+    ServiceRequest: ServiceRequest;
+    DetectedIssue: DetectedIssue;
+    Device: Device;
+    RequestGroup: RequestGroup;
+    TestScript: TestScript;
+    RiskEvidenceSynthesis: RiskEvidenceSynthesis;
+    SupplyRequest: SupplyRequest;
+    Task: Task;
+    CommunicationRequest: CommunicationRequest;
+    EnrollmentRequest: EnrollmentRequest;
+    ChargeItemDefinition: ChargeItemDefinition;
+    Substance: Substance;
+    Provenance: Provenance;
+    Consent: Consent;
+    CarePlan: CarePlan;
+    TestReport: TestReport;
+    Observation: Observation;
+    DocumentManifest: DocumentManifest;
+};
+export type ResourceType = keyof ResourceTypeMap;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/indexPackage.js b/vendor/r4/types/hl7-fhir-r4-core/indexPackage.js
new file mode 100644
index 0000000..3f74d94
--- /dev/null
+++ b/vendor/r4/types/hl7-fhir-r4-core/indexPackage.js
@@ -0,0 +1,213 @@
+"use strict";
+/** GENERATED BY zen-cli
+DON'T MODIFY MANUALLY */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./ImmunizationEvaluation"), exports);
+tslib_1.__exportStar(require("./Appointment"), exports);
+tslib_1.__exportStar(require("./StructureMap"), exports);
+tslib_1.__exportStar(require("./Address"), exports);
+tslib_1.__exportStar(require("./CareTeam"), exports);
+tslib_1.__exportStar(require("./UsageContext"), exports);
+tslib_1.__exportStar(require("./Linkage"), exports);
+tslib_1.__exportStar(require("./Annotation"), exports);
+tslib_1.__exportStar(require("./Age"), exports);
+tslib_1.__exportStar(require("./Attachment"), exports);
+tslib_1.__exportStar(require("./positiveInt"), exports);
+tslib_1.__exportStar(require("./unsignedInt"), exports);
+tslib_1.__exportStar(require("./Communication"), exports);
+tslib_1.__exportStar(require("./MedicationDispense"), exports);
+tslib_1.__exportStar(require("./ImagingStudy"), exports);
+tslib_1.__exportStar(require("./ChargeItem"), exports);
+tslib_1.__exportStar(require("./Period"), exports);
+tslib_1.__exportStar(require("./AdverseEvent"), exports);
+tslib_1.__exportStar(require("./url"), exports);
+tslib_1.__exportStar(require("./ContactDetail"), exports);
+tslib_1.__exportStar(require("./DataRequirement"), exports);
+tslib_1.__exportStar(require("./Media"), exports);
+tslib_1.__exportStar(require("./CodeableConcept"), exports);
+tslib_1.__exportStar(require("./SubstancePolymer"), exports);
+tslib_1.__exportStar(require("./QuestionnaireResponse"), exports);
+tslib_1.__exportStar(require("./Coverage"), exports);
+tslib_1.__exportStar(require("./Procedure"), exports);
+tslib_1.__exportStar(require("./AuditEvent"), exports);
+tslib_1.__exportStar(require("./PaymentReconciliation"), exports);
+tslib_1.__exportStar(require("./MedicinalProductManufactured"), exports);
+tslib_1.__exportStar(require("./CompartmentDefinition"), exports);
+tslib_1.__exportStar(require("./Organization"), exports);
+tslib_1.__exportStar(require("./ExplanationOfBenefit"), exports);
+tslib_1.__exportStar(require("./Composition"), exports);
+tslib_1.__exportStar(require("./SimpleQuantity"), exports);
+tslib_1.__exportStar(require("./CoverageEligibilityResponse"), exports);
+tslib_1.__exportStar(require("./DocumentReference"), exports);
+tslib_1.__exportStar(require("./EventDefinition"), exports);
+tslib_1.__exportStar(require("./SubstanceProtein"), exports);
+tslib_1.__exportStar(require("./TerminologyCapabilities"), exports);
+tslib_1.__exportStar(require("./Encounter"), exports);
+tslib_1.__exportStar(require("./ImplementationGuide"), exports);
+tslib_1.__exportStar(require("./EvidenceVariable"), exports);
+tslib_1.__exportStar(require("./ObservationDefinition"), exports);
+tslib_1.__exportStar(require("./DiagnosticReport"), exports);
+tslib_1.__exportStar(require("./ExampleScenario"), exports);
+tslib_1.__exportStar(require("./ResearchDefinition"), exports);
+tslib_1.__exportStar(require("./Parameters"), exports);
+tslib_1.__exportStar(require("./SearchParameter"), exports);
+tslib_1.__exportStar(require("./MedicinalProductInteraction"), exports);
+tslib_1.__exportStar(require("./CodeSystem"), exports);
+tslib_1.__exportStar(require("./MessageDefinition"), exports);
+tslib_1.__exportStar(require("./NutritionOrder"), exports);
+tslib_1.__exportStar(require("./xhtml"), exports);
+tslib_1.__exportStar(require("./VerificationResult"), exports);
+tslib_1.__exportStar(require("./MedicationAdministration"), exports);
+tslib_1.__exportStar(require("./CatalogEntry"), exports);
+tslib_1.__exportStar(require("./Flag"), exports);
+tslib_1.__exportStar(require("./DeviceUseStatement"), exports);
+tslib_1.__exportStar(require("./TriggerDefinition"), exports);
+tslib_1.__exportStar(require("./uri"), exports);
+tslib_1.__exportStar(require("./Contract"), exports);
+tslib_1.__exportStar(require("./Invoice"), exports);
+tslib_1.__exportStar(require("./MarketingStatus"), exports);
+tslib_1.__exportStar(require("./Count"), exports);
+tslib_1.__exportStar(require("./PaymentNotice"), exports);
+tslib_1.__exportStar(require("./Location"), exports);
+tslib_1.__exportStar(require("./Claim"), exports);
+tslib_1.__exportStar(require("./Specimen"), exports);
+tslib_1.__exportStar(require("./MedicationStatement"), exports);
+tslib_1.__exportStar(require("./EnrollmentResponse"), exports);
+tslib_1.__exportStar(require("./Evidence"), exports);
+tslib_1.__exportStar(require("./Bundle"), exports);
+tslib_1.__exportStar(require("./ResearchElementDefinition"), exports);
+tslib_1.__exportStar(require("./Expression"), exports);
+tslib_1.__exportStar(require("./Coding"), exports);
+tslib_1.__exportStar(require("./BodyStructure"), exports);
+tslib_1.__exportStar(require("./id"), exports);
+tslib_1.__exportStar(require("./MedicinalProduct"), exports);
+tslib_1.__exportStar(require("./dateTime"), exports);
+tslib_1.__exportStar(require("./ResearchStudy"), exports);
+tslib_1.__exportStar(require("./Dosage"), exports);
+tslib_1.__exportStar(require("./AppointmentResponse"), exports);
+tslib_1.__exportStar(require("./MedicinalProductIndication"), exports);
+tslib_1.__exportStar(require("./Measure"), exports);
+tslib_1.__exportStar(require("./Person"), exports);
+tslib_1.__exportStar(require("./InsurancePlan"), exports);
+tslib_1.__exportStar(require("./Patient"), exports);
+tslib_1.__exportStar(require("./EffectEvidenceSynthesis"), exports);
+tslib_1.__exportStar(require("./ResearchSubject"), exports);
+tslib_1.__exportStar(require("./Medication"), exports);
+tslib_1.__exportStar(require("./Range"), exports);
+tslib_1.__exportStar(require("./ConceptMap"), exports);
+tslib_1.__exportStar(require("./CoverageEligibilityRequest"), exports);
+tslib_1.__exportStar(require("./Population"), exports);
+tslib_1.__exportStar(require("./SubstanceSourceMaterial"), exports);
+tslib_1.__exportStar(require("./VisionPrescription"), exports);
+tslib_1.__exportStar(require("./oid"), exports);
+tslib_1.__exportStar(require("./MolecularSequence"), exports);
+tslib_1.__exportStar(require("./MedicinalProductUndesirableEffect"), exports);
+tslib_1.__exportStar(require("./OperationOutcome"), exports);
+tslib_1.__exportStar(require("./MessageHeader"), exports);
+tslib_1.__exportStar(require("./ContactPoint"), exports);
+tslib_1.__exportStar(require("./uuid"), exports);
+tslib_1.__exportStar(require("./Signature"), exports);
+tslib_1.__exportStar(require("./AllergyIntolerance"), exports);
+tslib_1.__exportStar(require("./SubstanceReferenceInformation"), exports);
+tslib_1.__exportStar(require("./SupplyDelivery"), exports);
+tslib_1.__exportStar(require("./EpisodeOfCare"), exports);
+tslib_1.__exportStar(require("./PractitionerRole"), exports);
+tslib_1.__exportStar(require("./Library"), exports);
+tslib_1.__exportStar(require("./Practitioner"), exports);
+tslib_1.__exportStar(require("./MedicationRequest"), exports);
+tslib_1.__exportStar(require("./ImmunizationRecommendation"), exports);
+tslib_1.__exportStar(require("./RelatedArtifact"), exports);
+tslib_1.__exportStar(require("./Timing"), exports);
+tslib_1.__exportStar(require("./Immunization"), exports);
+tslib_1.__exportStar(require("./GraphDefinition"), exports);
+tslib_1.__exportStar(require("./Account"), exports);
+tslib_1.__exportStar(require("./MedicinalProductIngredient"), exports);
+tslib_1.__exportStar(require("./ProdCharacteristic"), exports);
+tslib_1.__exportStar(require("./Meta"), exports);
+tslib_1.__exportStar(require("./Quantity"), exports);
+tslib_1.__exportStar(require("./MeasureReport"), exports);
+tslib_1.__exportStar(require("./Distance"), exports);
+tslib_1.__exportStar(require("./canonical"), exports);
+tslib_1.__exportStar(require("./HumanName"), exports);
+tslib_1.__exportStar(require("./DeviceMetric"), exports);
+tslib_1.__exportStar(require("./Duration"), exports);
+tslib_1.__exportStar(require("./SubstanceAmount"), exports);
+tslib_1.__exportStar(require("./Goal"), exports);
+tslib_1.__exportStar(require("./time"), exports);
+tslib_1.__exportStar(require("./MedicationKnowledge"), exports);
+tslib_1.__exportStar(require("./ClaimResponse"), exports);
+tslib_1.__exportStar(require("./DeviceDefinition"), exports);
+tslib_1.__exportStar(require("./Slot"), exports);
+tslib_1.__exportStar(require("./ValueSet"), exports);
+tslib_1.__exportStar(require("./MedicinalProductAuthorization"), exports);
+tslib_1.__exportStar(require("./StructureDefinition"), exports);
+tslib_1.__exportStar(require("./integer"), exports);
+tslib_1.__exportStar(require("./MedicinalProductContraindication"), exports);
+tslib_1.__exportStar(require("./ElementDefinition"), exports);
+tslib_1.__exportStar(require("./DeviceRequest"), exports);
+tslib_1.__exportStar(require("./List"), exports);
+tslib_1.__exportStar(require("./Questionnaire"), exports);
+tslib_1.__exportStar(require("./DomainResource"), exports);
+tslib_1.__exportStar(require("./Endpoint"), exports);
+tslib_1.__exportStar(require("./NamingSystem"), exports);
+tslib_1.__exportStar(require("./MedicinalProductPackaged"), exports);
+tslib_1.__exportStar(require("./Basic"), exports);
+tslib_1.__exportStar(require("./Money"), exports);
+tslib_1.__exportStar(require("./Binary"), exports);
+tslib_1.__exportStar(require("./PlanDefinition"), exports);
+tslib_1.__exportStar(require("./Subscription"), exports);
+tslib_1.__exportStar(require("./SampledData"), exports);
+tslib_1.__exportStar(require("./ProductShelfLife"), exports);
+tslib_1.__exportStar(require("./RelatedPerson"), exports);
+tslib_1.__exportStar(require("./SubstanceSpecification"), exports);
+tslib_1.__exportStar(require("./date"), exports);
+tslib_1.__exportStar(require("./Ratio"), exports);
+tslib_1.__exportStar(require("./markdown"), exports);
+tslib_1.__exportStar(require("./SubstanceNucleicAcid"), exports);
+tslib_1.__exportStar(require("./GuidanceResponse"), exports);
+tslib_1.__exportStar(require("./ClinicalImpression"), exports);
+tslib_1.__exportStar(require("./OrganizationAffiliation"), exports);
+tslib_1.__exportStar(require("./Resource"), exports);
+tslib_1.__exportStar(require("./Condition"), exports);
+tslib_1.__exportStar(require("./Extension"), exports);
+tslib_1.__exportStar(require("./CapabilityStatement"), exports);
+tslib_1.__exportStar(require("./HealthcareService"), exports);
+tslib_1.__exportStar(require("./SpecimenDefinition"), exports);
+tslib_1.__exportStar(require("./ParameterDefinition"), exports);
+tslib_1.__exportStar(require("./RiskAssessment"), exports);
+tslib_1.__exportStar(require("./OperationDefinition"), exports);
+tslib_1.__exportStar(require("./ActivityDefinition"), exports);
+tslib_1.__exportStar(require("./Schedule"), exports);
+tslib_1.__exportStar(require("./BiologicallyDerivedProduct"), exports);
+tslib_1.__exportStar(require("./Group"), exports);
+tslib_1.__exportStar(require("./MedicinalProductPharmaceutical"), exports);
+tslib_1.__exportStar(require("./base64Binary"), exports);
+tslib_1.__exportStar(require("./FamilyMemberHistory"), exports);
+tslib_1.__exportStar(require("./ServiceRequest"), exports);
+tslib_1.__exportStar(require("./DetectedIssue"), exports);
+tslib_1.__exportStar(require("./instant"), exports);
+tslib_1.__exportStar(require("./Device"), exports);
+tslib_1.__exportStar(require("./RequestGroup"), exports);
+tslib_1.__exportStar(require("./TestScript"), exports);
+tslib_1.__exportStar(require("./RiskEvidenceSynthesis"), exports);
+tslib_1.__exportStar(require("./SupplyRequest"), exports);
+tslib_1.__exportStar(require("./Element"), exports);
+tslib_1.__exportStar(require("./Reference"), exports);
+tslib_1.__exportStar(require("./code"), exports);
+tslib_1.__exportStar(require("./Task"), exports);
+tslib_1.__exportStar(require("./Identifier"), exports);
+tslib_1.__exportStar(require("./CommunicationRequest"), exports);
+tslib_1.__exportStar(require("./EnrollmentRequest"), exports);
+tslib_1.__exportStar(require("./ChargeItemDefinition"), exports);
+tslib_1.__exportStar(require("./Substance"), exports);
+tslib_1.__exportStar(require("./Provenance"), exports);
+tslib_1.__exportStar(require("./Consent"), exports);
+tslib_1.__exportStar(require("./BackboneElement"), exports);
+tslib_1.__exportStar(require("./CarePlan"), exports);
+tslib_1.__exportStar(require("./Narrative"), exports);
+tslib_1.__exportStar(require("./decimal"), exports);
+tslib_1.__exportStar(require("./TestReport"), exports);
+tslib_1.__exportStar(require("./Observation"), exports);
+tslib_1.__exportStar(require("./DocumentManifest"), exports);
+tslib_1.__exportStar(require("./Contributor"), exports);
diff --git a/vendor/r4/types/hl7-fhir-r4-core/instant.d.ts b/vendor/r4/types/hl7-fhir-r4-core/instant.d.ts
index e31605e..ff17eb0 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/instant.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/instant.d.ts
@@ -1,6 +1,6 @@
 /** GENERATED BY zen-cli
 DON'T MODIFY MANUALLY */
 /** Base StructureDefinition for instant Type: An instant in time - known at least to the second
- * @pattern ^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))$
+* @pattern ^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))$
  */
 export type instant = string;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/oid.d.ts b/vendor/r4/types/hl7-fhir-r4-core/oid.d.ts
index 8efabde..aa16572 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/oid.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/oid.d.ts
@@ -2,6 +2,6 @@
 DON'T MODIFY MANUALLY */
 import { uri } from "./uri";
 /** Base StructureDefinition for oid type: An OID represented as a URI
- * @pattern ^urn:oid:[0-2](\.(0|[1-9][0-9]*))+$
+* @pattern ^urn:oid:[0-2](\.(0|[1-9][0-9]*))+$
  */
 export type oid = uri;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/positiveInt.d.ts b/vendor/r4/types/hl7-fhir-r4-core/positiveInt.d.ts
index 5cc0e6d..d4d72c1 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/positiveInt.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/positiveInt.d.ts
@@ -2,6 +2,6 @@
 DON'T MODIFY MANUALLY */
 import { integer } from "./integer";
 /** Base StructureDefinition for positiveInt type: An integer with a value that is positive (e.g. >0)
- * @minimum 1
+* @minimum 1
  */
 export type positiveInt = integer;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/time.d.ts b/vendor/r4/types/hl7-fhir-r4-core/time.d.ts
index eca69e1..f952b98 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/time.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/time.d.ts
@@ -1,6 +1,6 @@
 /** GENERATED BY zen-cli
 DON'T MODIFY MANUALLY */
 /** Base StructureDefinition for time Type: A time during the day, with no date specified
- * @pattern ^([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?$
+* @pattern ^([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?$
  */
 export type time = string;
diff --git a/vendor/r4/types/hl7-fhir-r4-core/unsignedInt.d.ts b/vendor/r4/types/hl7-fhir-r4-core/unsignedInt.d.ts
index 405820e..a0e6f54 100644
--- a/vendor/r4/types/hl7-fhir-r4-core/unsignedInt.d.ts
+++ b/vendor/r4/types/hl7-fhir-r4-core/unsignedInt.d.ts
@@ -2,6 +2,6 @@
 DON'T MODIFY MANUALLY */
 import { integer } from "./integer";
 /** Base StructureDefinition for unsignedInt type: An integer with a value that is not negative (e.g. >= 0)
- * @minimum 0
+* @minimum 0
  */
 export type unsignedInt = integer;
diff --git a/vendor/r4/types/index.d.ts b/vendor/r4/types/index.d.ts
index 3d53045..90605ef 100644
--- a/vendor/r4/types/index.d.ts
+++ b/vendor/r4/types/index.d.ts
@@ -1,26 +1,5 @@
 /** GENERATED BY zen-cli
 DON'T MODIFY MANUALLY */
-export * from "./workflow";
-export * from "./task";
-import { ResourceType } from "./hl7-fhir-r4-core";
-export * from "./hl7-fhir-r4-core";
-export interface SubsSubscription {
-    id?: string;
-    resourceType: "SubsSubscription";
-    status: "active" | "off";
-    trigger: Partial<Record<ResourceType, {
-        event: Array<"all" | "create" | "update" | "delete">;
-        filter?: unknown;
-    }>>;
-    channel: {
-        type: "rest-hook";
-        endpoint: string;
-        payload?: {
-            content: string;
-            contentType: string;
-            context: unknown;
-        };
-        headers?: Record<string, string>;
-        timeout?: number;
-    };
-}
+export * from './workflow';
+export * from './task';
+export * from './hl7-fhir-r4-core/indexPackage';
diff --git a/vendor/r4/types/index.js b/vendor/r4/types/index.js
index 156f03d..e6bb82e 100644
--- a/vendor/r4/types/index.js
+++ b/vendor/r4/types/index.js
@@ -1,21 +1,8 @@
 "use strict";
 /** GENERATED BY zen-cli
 DON'T MODIFY MANUALLY */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./workflow"), exports);
-__exportStar(require("./task"), exports);
-__exportStar(require("./hl7-fhir-r4-core"), exports);
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./workflow"), exports);
+tslib_1.__exportStar(require("./task"), exports);
+tslib_1.__exportStar(require("./hl7-fhir-r4-core/indexPackage"), exports);
diff --git a/vendor/r4/types/task/SystemSendMessage.d.ts b/vendor/r4/types/task/SystemSendMessage.d.ts
new file mode 100644
index 0000000..30c981b
--- /dev/null
+++ b/vendor/r4/types/task/SystemSendMessage.d.ts
@@ -0,0 +1,13 @@
+/** GENERATED BY zen-cli
+DON'T MODIFY MANUALLY */
+export interface SystemSendMessage {
+    params?: SystemSendMessageParams;
+    result?: SystemSendMessageResult;
+}
+export interface SystemSendMessageParams {
+    phone: string;
+    message: string;
+}
+export interface SystemSendMessageResult {
+    status: string;
+}
diff --git a/vendor/r4/types/task/SystemSendMessage.js b/vendor/r4/types/task/SystemSendMessage.js
new file mode 100644
index 0000000..1592a18
--- /dev/null
+++ b/vendor/r4/types/task/SystemSendMessage.js
@@ -0,0 +1,4 @@
+"use strict";
+/** GENERATED BY zen-cli
+DON'T MODIFY MANUALLY */
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/vendor/r4/types/task/index.d.ts b/vendor/r4/types/task/index.d.ts
index 349c1f7..14da841 100644
--- a/vendor/r4/types/task/index.d.ts
+++ b/vendor/r4/types/task/index.d.ts
@@ -1,4 +1,24 @@
 /** GENERATED BY zen-cli
 DON'T MODIFY MANUALLY */
-export type TaskDefinitionsMap = {};
+import { SystemSendMessage } from './SystemSendMessage';
+type WaitTaskDuration = {
+    duration: {
+        hours: number;
+        minutes: number;
+        seconds: number;
+    };
+    until?: never;
+};
+type WaitTaskUntil = {
+    duration?: never;
+    until: string;
+};
+export type TaskDefinitionsMap = {
+    'awf.task/wait': {
+        params: WaitTaskDuration | WaitTaskUntil;
+        result: Record<string, unknown>;
+    };
+    'system/SendMessage': SystemSendMessage;
+};
 export declare const TaskDefinitionsNameMap: Record<keyof TaskDefinitionsMap, string>;
+export {};
diff --git a/vendor/r4/types/task/index.js b/vendor/r4/types/task/index.js
index 330a304..c116d23 100644
--- a/vendor/r4/types/task/index.js
+++ b/vendor/r4/types/task/index.js
@@ -3,4 +3,6 @@
 DON'T MODIFY MANUALLY */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskDefinitionsNameMap = void 0;
-exports.TaskDefinitionsNameMap = {};
+exports.TaskDefinitionsNameMap = {
+    SystemSendMessage: 'system/SendMessage'
+};
diff --git a/vendor/r4/types/workflow/SystemCheckOutWorkflow.d.ts b/vendor/r4/types/workflow/SystemCheckOutWorkflow.d.ts
new file mode 100644
index 0000000..e5bcb88
--- /dev/null
+++ b/vendor/r4/types/workflow/SystemCheckOutWorkflow.d.ts
@@ -0,0 +1,16 @@
+/** GENERATED BY zen-cli
+DON'T MODIFY MANUALLY */
+export interface SystemCheckOutWorkflow {
+    params?: SystemCheckOutWorkflowParams;
+    result?: SystemCheckOutWorkflowResult;
+    error?: SystemCheckOutWorkflowError;
+}
+export interface SystemCheckOutWorkflowParams {
+    clientId: string;
+}
+export interface SystemCheckOutWorkflowResult {
+    messageId?: string;
+}
+export interface SystemCheckOutWorkflowError {
+    message?: string;
+}
diff --git a/vendor/r4/types/workflow/SystemCheckOutWorkflow.js b/vendor/r4/types/workflow/SystemCheckOutWorkflow.js
new file mode 100644
index 0000000..1592a18
--- /dev/null
+++ b/vendor/r4/types/workflow/SystemCheckOutWorkflow.js
@@ -0,0 +1,4 @@
+"use strict";
+/** GENERATED BY zen-cli
+DON'T MODIFY MANUALLY */
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/vendor/r4/types/workflow/index.d.ts b/vendor/r4/types/workflow/index.d.ts
index 0452dbf..ba1715c 100644
--- a/vendor/r4/types/workflow/index.d.ts
+++ b/vendor/r4/types/workflow/index.d.ts
@@ -1,4 +1,7 @@
 /** GENERATED BY zen-cli
 DON'T MODIFY MANUALLY */
-export type WorkflowDefinitionsMap = {};
+import { SystemCheckOutWorkflow } from './SystemCheckOutWorkflow';
+export type WorkflowDefinitionsMap = {
+    'system/CheckOutWorkflow': SystemCheckOutWorkflow;
+};
 export declare const WorkflowDefinitionsNameMap: Record<keyof WorkflowDefinitionsMap, string>;
diff --git a/vendor/r4/types/workflow/index.js b/vendor/r4/types/workflow/index.js
index 36c4d1f..1d3ac7c 100644
--- a/vendor/r4/types/workflow/index.js
+++ b/vendor/r4/types/workflow/index.js
@@ -3,4 +3,6 @@
 DON'T MODIFY MANUALLY */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowDefinitionsNameMap = void 0;
-exports.WorkflowDefinitionsNameMap = {};
+exports.WorkflowDefinitionsNameMap = {
+    SystemCheckOutWorkflow: 'system/CheckOutWorkflow'
+};
diff --git a/vendor/r4/zen-project/tsconfig.json b/vendor/r4/zen-project/tsconfig.json
deleted file mode 100644
index d9e72af..0000000
--- a/vendor/r4/zen-project/tsconfig.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es6",
-    "module": "CommonJS",
-    "declaration": true,
-    "outDir": "./lib",
-    "strict": true,
-    "checkJs": false,
-    "skipLibCheck": true,
-    "skipDefaultLibCheck": true,
-    "lib": ["es2020", "dom"]
-  },
-  "exclude": ["node_modules", "lib"]
-}
diff --git a/vendor/r4/zen-project/zen-package.edn b/vendor/r4/zen-project/zen-package.edn
deleted file mode 100644
index eac5ef2..0000000
--- a/vendor/r4/zen-project/zen-package.edn
+++ /dev/null
@@ -1 +0,0 @@
-{:deps {hl7-fhir-r4-core "https://github.com/zen-fhir/hl7-fhir-r4-core.git"}}
\ No newline at end of file
diff --git a/vendor/r4/zen-project/zrc/system.edn b/vendor/r4/zen-project/zrc/system.edn
deleted file mode 100644
index ded6cc0..0000000
--- a/vendor/r4/zen-project/zrc/system.edn
+++ /dev/null
@@ -1,32 +0,0 @@
-{ns system
- import #{aidbox  hl7-fhir-r4-core awf.workflow awf.task}
-
- admin-user-seed
- {:zen/tags #{aidbox/service}
-  :engine   aidbox/seed-v2
-  :resources
-  {:User {:admin
-          {:password #env AIDBOX_ADMIN_PASSWORD}}
-
-   :AccessPolicy {:allow-admin-user
-                  {:engine "allow"
-                   :link   [{:resourceType "User" :id "admin"}]}}}}
- demo-client-seed
- {:zen/tags #{aidbox/service}
-  :engine   aidbox/seed-v2
-  :resources
-  {:Client {:demo
-            {:name        "Demo client"
-             :secret      #env AIDBOX_CLIENT_SECRET
-             :first_party true
-             :grant_types ["basic"]}}
-
-   :AccessPolicy {:allow-demo-client
-                  {:engine "allow"
-                   :link   [{:resourceType "Client" :id "demo"}]}}}}
-
-
- box
- {:zen/tags #{aidbox/system}
-  :services {:admin-user-seed admin-user-seed
-             :demo-client-seed demo-client-seed}}}
\ No newline at end of file