@medplum/core 2.1.4 → 2.1.6

package/dist/types/base-schema.d.ts

@@ -0,0 +1,7 @@
+import { InternalSchemaElement, InternalTypeSchema } from './typeschema/types';
+export type BaseSchema = Record<string, {
+    elements: Record<string, Partial<InternalSchemaElement>>;
+}>;
+export declare function compressElement(element: InternalSchemaElement): Partial<InternalSchemaElement>;
+export declare function inflateElement(partial: Partial<InternalSchemaElement>): InternalSchemaElement;
+export declare function inflateBaseSchema(base: BaseSchema): Record<string, InternalTypeSchema>;

package/dist/types/client.d.ts

@@ -2,10 +2,10 @@ import { AccessPolicy, Agent, Attachment, Binary, BulkDataExport, Bundle, Commun
 /** @ts-ignore */
 import type { CustomTableLayout, TDocumentDefinitions, TFontDictionary } from 'pdfmake/interfaces';
 import { EventTarget } from './eventtarget';
+import { FhircastConnection, FhircastEventContext, FhircastEventName, SubscriptionRequest } from './fhircast';
 import { Hl7Message } from './hl7';
 import { ReadablePromise } from './readablepromise';
 import { ClientStorage } from './storage';
-import { IndexedStructureDefinition } from './types';
 import { CodeChallengeMethod, ProfileResource } from './utils';
 export declare const MEDPLUM_VERSION: string;
 /**
@@ -907,15 +907,6 @@ export declare class MedplumClient extends EventTarget {
      * @returns The resource if available; undefined otherwise.
      */
     readReference<T extends Resource>(reference: Reference<T>, options?: RequestInit): ReadablePromise<T>;
-    /**
-     * Returns a cached schema for a resource type.
-     * If the schema is not cached, returns undefined.
-     * It is assumed that a client will call requestSchema before using this method.
-     * @category Schema
-     * @returns The schema if immediately available, undefined otherwise.
-     * @deprecated Use globalSchema instead.
-     */
-    getSchema(): IndexedStructureDefinition;
     /**
      * Requests the schema for a resource type.
      * If the schema is already cached, the promise is resolved immediately.
@@ -923,7 +914,7 @@ export declare class MedplumClient extends EventTarget {
      * @param resourceType The FHIR resource type.
      * @returns Promise to a schema with the requested resource type.
      */
-    requestSchema(resourceType: string): Promise<IndexedStructureDefinition>;
+    requestSchema(resourceType: string): Promise<void>;
     /**
      * Reads resource history by resource type and ID.
      *
@@ -1455,9 +1446,9 @@ export declare class MedplumClient extends EventTarget {
      */
     getProfile(): ProfileResource | undefined;
     /**
-     * Returns the current user profile resource if available.
+     * Returns the current user profile resource, retrieving form the server if necessary.
      * This method waits for loading promises.
-     * @returns The current user profile resource if available.
+     * @returns The current user profile resource.
      * @category User Profile
      */
     getProfileAsync(): Promise<ProfileResource | undefined>;
@@ -1667,6 +1658,43 @@ export declare class MedplumClient extends EventTarget {
      * @param clientSecret The client secret.
      */
     setBasicAuth(clientId: string, clientSecret: string): void;
+    /**
+     * Subscribes to a specified topic, listening for a list of specified events.
+     *
+     * Once you have the `SubscriptionRequest` returned from this method, you can call `fhircastConnect(subscriptionRequest)` to connect to the subscription stream.
+     *
+     * @category FHIRcast
+     * @param topic The topic to publish to. Usually a UUID.
+     * @param events An array of event names to listen for.
+     * @returns A `Promise` that resolves once the request completes, or rejects if it fails.
+     */
+    fhircastSubscribe(topic: string, events: FhircastEventName[]): Promise<SubscriptionRequest>;
+    /**
+     * Unsubscribes from the specified topic.
+     *
+     * @category FHIRcast
+     * @param subRequest A `SubscriptionRequest` representing a subscription to cancel. Mode will be set to `unsubscribe` automatically.
+     * @returns A `Promise` that resolves when request to unsubscribe is completed.
+     */
+    fhircastUnsubscribe(subRequest: SubscriptionRequest): Promise<void>;
+    /**
+     * Connects to a `FHIRcast` session.
+     *
+     * @category FHIRcast
+     * @param subRequest The `SubscriptionRequest` to use for connecting.
+     * @returns A `FhircastConnection` which emits lifecycle events for the `FHIRcast` WebSocket connection.
+     */
+    fhircastConnect(subRequest: SubscriptionRequest): FhircastConnection;
+    /**
+     * Publishes a new context to a given topic for a specified event type.
+     *
+     * @category FHIRcast
+     * @param topic The topic to publish to. Usually a UUID.
+     * @param event The name of the event to publish an updated context for, ie. `patient-open`.
+     * @param context The updated context containing resources relevant to this event.
+     * @returns A `Promise` that resolves once the request completes, or rejects if it fails.
+     */
+    fhircastPublish(topic: string, event: FhircastEventName, context: FhircastEventContext | FhircastEventContext[]): Promise<void>;
     /**
      * Invite a user to a project.
      * @param projectId The project ID.

package/dist/types/eventtarget.d.ts

@@ -10,3 +10,9 @@ export declare class EventTarget {
     removeEventListener(type: string, callback: EventListener): void;
     dispatchEvent(event: Event): boolean;
 }
+export declare class TypedEventTarget<TEvents extends Record<string, Event>> {
+    private emitter;
+    dispatchEvent<TEventType extends keyof TEvents & string>(event: TEvents[TEventType]): void;
+    addEventListener<TEventType extends keyof TEvents & string>(type: TEventType, handler: (event: TEvents[TEventType]) => void): void;
+    removeEventListener<TEventType extends keyof TEvents & string>(type: TEventType, handler: (event: TEvents[TEventType]) => void): void;
+}

package/dist/types/fhircast/index.d.ts

@@ -0,0 +1,115 @@
+import type { Resource } from '@medplum/fhirtypes';
+import { TypedEventTarget } from '../eventtarget';
+declare const FHIRCAST_EVENT_NAMES: {
+    readonly 'patient-open': "patient-open";
+    readonly 'patient-close': "patient-close";
+    readonly 'imagingstudy-open': "imagingstudy-open";
+    readonly 'imagingstudy-close': "imagingstudy-close";
+};
+declare const FHIRCAST_RESOURCE_TYPES: readonly ["Patient", "Encounter", "ImagingStudy"];
+export type FhircastEventName = keyof typeof FHIRCAST_EVENT_NAMES;
+export type FhircastResourceType = (typeof FHIRCAST_RESOURCE_TYPES)[number];
+/**
+ * Checks if a `ResourceType` can be used in a `FHIRcast` context.
+ *
+ * @param resourceType A `ResourceType` to test.
+ * @returns `true` if this is a resource type associated with `FHIRcast` contexts, otherwise returns `false`.
+ */
+export declare function isFhircastResourceType(resourceType: FhircastResourceType): boolean;
+/**
+ * A `FHIRcast` subscription request.
+ *
+ * Can be passed to `MedplumClient.fhircastConnect` or `MedplumClient.fhircastUnsubscribe` to either open a `FHIRcast` connection, or unsubscribe from the subscription.
+ */
+export type SubscriptionRequest = {
+    channelType: 'websocket';
+    mode: 'subscribe' | 'unsubscribe';
+    events: FhircastEventName[];
+    topic: string;
+    endpoint: string;
+};
+export type PendingSubscriptionRequest = Omit<SubscriptionRequest, 'endpoint'>;
+declare const FHIRCAST_CONTEXT_KEY_LOOKUP: {
+    readonly study: "ImagingStudy";
+    readonly patient: "Patient";
+    readonly encounter: "Encounter";
+};
+type FhircastEventContextMap = typeof FHIRCAST_CONTEXT_KEY_LOOKUP;
+type FhircastEventContextKey = keyof FhircastEventContextMap;
+export type FhircastEventContext<K extends FhircastEventContextKey = FhircastEventContextKey> = {
+    key: K;
+    resource: Resource & {
+        resourceType: FhircastEventContextMap[K];
+        id: string;
+    };
+};
+export type FhircastEventPayload = {
+    'hub.topic': string;
+    'hub.event': string;
+    context: FhircastEventContext[];
+};
+export type FhircastMessagePayload = {
+    timestamp: string;
+    id: string;
+    event: FhircastEventPayload;
+};
+export declare function isCompletedSubscriptionRequest(subscriptionRequest: SubscriptionRequest | PendingSubscriptionRequest): subscriptionRequest is SubscriptionRequest;
+/**
+ * Creates a serialized url-encoded payload for a `FHIRcast` subscription from a `SubscriptionRequest` object that can be directly used in an HTTP request to the Hub.
+ *
+ * @param subscriptionRequest An object representing a subscription request.
+ * @returns A serialized subscription in url-encoded form.
+ */
+export declare function serializeFhircastSubscriptionRequest(subscriptionRequest: SubscriptionRequest | PendingSubscriptionRequest): string;
+/**
+ * Validates that a `SubscriptionRequest`.
+ *
+ * @param subscriptionRequest The `SubscriptionRequest` to validate.
+ * @returns A `boolean` indicating whether or not the `SubscriptionRequest` is valid.
+ */
+export declare function validateFhircastSubscriptionRequest(subscriptionRequest: SubscriptionRequest | PendingSubscriptionRequest): boolean;
+/**
+ * Creates a serializable JSON payload for the `FHIRcast` protocol
+ *
+ * @param topic The topic that this message will be published on. Usually a UUID.
+ * @param event The event name, ie. "patient-open" or "patient-close".
+ * @param context The updated context, containing new versions of resources related to this event.
+ * @returns A serializable `FhircastMessagePayload`.
+ */
+export declare function createFhircastMessagePayload(topic: string, event: FhircastEventName, context: FhircastEventContext | FhircastEventContext[]): FhircastMessagePayload;
+export type FhircastConnectEvent = {
+    type: 'connect';
+};
+export type FhircastMessageEvent = {
+    type: 'message';
+    payload: FhircastMessagePayload;
+};
+export type FhircastDisconnectEvent = {
+    type: 'disconnect';
+};
+export type FhircastSubscriptionEventMap = {
+    connect: FhircastConnectEvent;
+    message: FhircastMessageEvent;
+    disconnect: FhircastDisconnectEvent;
+};
+/**
+ * A class representing a `FHIRcast` connection.
+ *
+ * `FhircastConnection` extends `EventTarget` and emits 3 lifecycle events:
+ * 1. `connect` - An event to signal when a WebSocket connection has been opened. Fired as soon as a WebSocket emits `open`.
+ * 2. `message` - Contains a `payload` field containing a `FHIRcast` message payload exactly as it comes in over WebSockets.
+ * 3. `disconnect` - An event to signal when a WebSocket connection has been closed. Fired as soon as a WebSocket emits `close`.
+ *
+ * To close the connection, call `connection.disconnect()` and listen to the `disconnect` event to know when the connection has been disconnected.
+ */
+export declare class FhircastConnection extends TypedEventTarget<FhircastSubscriptionEventMap> {
+    subRequest: SubscriptionRequest;
+    private websocket;
+    /**
+     * Creates a new `FhircastConnection`.
+     * @param subRequest The subscription request to initialize the connection from.
+     */
+    constructor(subRequest: SubscriptionRequest);
+    disconnect(): void;
+}
+export {};

package/dist/types/fhircast/test-utils.d.ts

@@ -0,0 +1,2 @@
+import { FhircastEventContext, FhircastResourceType } from '.';
+export declare function createFhircastMessageContext(resourceType: Lowercase<FhircastResourceType>, resourceId: string): FhircastEventContext;

package/dist/types/fhirmapper/tokenize.d.ts

@@ -1,2 +1,2 @@
-import { Token } from '../fhirlexer';
+import { Token } from '../fhirlexer/tokenize';
 export declare function tokenize(str: string): Token[];

package/dist/types/fhirpath/atoms.d.ts

@@ -1,4 +1,4 @@
-import { Atom, AtomContext, InfixOperatorAtom, PrefixOperatorAtom } from '../fhirlexer';
+import { Atom, AtomContext, InfixOperatorAtom, PrefixOperatorAtom } from '../fhirlexer/parse';
 import { TypedValue } from '../types';
 export declare class FhirPathAtom implements Atom {
     readonly original: string;

package/dist/types/fhirpath/functions.d.ts

@@ -1,4 +1,4 @@
-import { Atom, AtomContext } from '../fhirlexer';
+import { Atom, AtomContext } from '../fhirlexer/parse';
 import { TypedValue } from '../types';
 export type FhirPathFunction = (context: AtomContext, input: TypedValue[], ...args: Atom[]) => TypedValue[];
 export declare const functions: Record<string, FhirPathFunction>;

package/dist/types/fhirpath/parse.d.ts

@@ -1,4 +1,4 @@
-import { ParserBuilder } from '../fhirlexer';
+import { ParserBuilder } from '../fhirlexer/parse';
 import { TypedValue } from '../types';
 import { FhirPathAtom } from './atoms';
 /**

package/dist/types/fhirpath/tokenize.d.ts

@@ -1,4 +1,4 @@
-import { Token } from '../fhirlexer';
+import { Token } from '../fhirlexer/tokenize';
 export declare const FHIRPATH_KEYWORDS: string[];
 export declare const FHIRPATH_OPERATORS: string[];
 export declare function tokenize(str: string): Token[];

package/dist/types/filter/tokenize.d.ts

@@ -1,2 +1,2 @@
-import { Token } from '../fhirlexer';
+import { Token } from '../fhirlexer/tokenize';
 export declare function tokenize(str: string): Token[];

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 export * from './access';
 export * from './base64';
+export * from './base-schema';
 export * from './bundle';
 export * from './cache';
 export * from './client';
@@ -8,10 +9,13 @@ export * from './constants';
 export * from './contenttype';
 export * from './crypto';
 export * from './eventtarget';
-export * from './fhirlexer';
-export * from './fhirmapper';
-export * from './fhirpath';
-export * from './filter';
+export * from './fhircast';
+export * from './fhirlexer/parse';
+export * from './fhirmapper/parse';
+export * from './fhirpath/parse';
+export * from './fhirpath/utils';
+export * from './filter/parse';
+export * from './filter/types';
 export * from './format';
 export * from './hl7';
 export * from './jwt';

package/dist/types/outcomes.d.ts

@@ -14,6 +14,7 @@ export declare function validationError(details: string): OperationOutcome;
 export declare function serverError(err: Error): OperationOutcome;
 export declare function isOperationOutcome(value: unknown): value is OperationOutcome;
 export declare function isOk(outcome: OperationOutcome): boolean;
+export declare function isCreated(outcome: OperationOutcome): boolean;
 export declare function isAccepted(outcome: OperationOutcome): boolean;
 export declare function isNotFound(outcome: OperationOutcome): boolean;
 export declare function isGone(outcome: OperationOutcome): boolean;

package/dist/types/schema.d.ts

@@ -1,36 +1,4 @@
-import { OperationOutcomeIssue, Resource } from '@medplum/fhirtypes';
-/**
- * Returns true if the given string is a valid FHIR resource type.
- *
- * ```ts
- * isResourceType('Patient'); // true
- * isResourceType('XYZ'); // false
- * ```
- *
- * Note that this depends on globalSchema, which is populated by the StructureDefinition loader.
- *
- * In a server context, you can load all schema definitions:
- *
- * ```ts
- * import { indexStructureDefinitionBundle } from '@medplum/core';
- * import { readJson } from '@medplum/definitions';
- * import { Bundle } from '@medplum/fhirtypes';
- *
- * indexStructureDefinitionBundle(readJson('fhir/r4/profiles-resources.json') as Bundle);
- * ```
- *
- * In a client context, you can load the schema definitions using MedplumClient:
- *
- * ```ts
- * import { MedplumClient } from '@medplum/core';
- *
- * const medplum = new MedplumClient();
- * await medplum.requestSchema('Patient');
- * ```
- * @param resourceType The candidate resource type string.
- * @returns True if the resource type is a valid FHIR resource type.
- */
-export declare function isResourceType(resourceType: string): boolean;
+import { OperationOutcomeIssue } from '@medplum/fhirtypes';
 /**
  * Validates that the given string is a valid FHIR resource type.
  * On success, silently returns void.
@@ -64,77 +32,6 @@ export declare function isResourceType(resourceType: string): boolean;
  * @param resourceType The candidate resource type string.
  */
 export declare function validateResourceType(resourceType: string): void;
-/**
- * Validates a candidate FHIR resource object.
- * On success, silently returns void.
- * On failure, throws an OperationOutcomeError with issues for each violation.
- *
- * ```ts
- * validateResource({ resourceType: 'Patient' }); // nothing
- * validateResource({ resourceType: 'XYZ' }); // throws OperationOutcomeError
- * ```
- *
- * Note that this depends on globalSchema, which is populated by the StructureDefinition loader.
- *
- * In a server context, you can load all schema definitions:
- *
- * ```ts
- * import { indexStructureDefinitionBundle } from '@medplum/core';
- * import { readJson } from '@medplum/definitions';
- * import { Bundle } from '@medplum/fhirtypes';
- *
- * indexStructureDefinitionBundle(readJson('fhir/r4/profiles-resources.json') as Bundle);
- * ```
- *
- * In a client context, you can load the schema definitions using MedplumClient:
- *
- * ```ts
- * import { MedplumClient } from '@medplum/core';
- *
- * const medplum = new MedplumClient();
- * await medplum.requestSchema('Patient');
- * ```
- * @param resource The candidate resource.
- * @deprecated use validate() instead
- */
-export declare function validateResource<T extends Resource>(resource: T): void;
-export declare class FhirSchemaValidator<T extends Resource> {
-    private readonly issues;
-    private readonly root;
-    constructor(root: T);
-    validate(): void;
-    private validateObject;
-    private checkProperties;
-    private checkProperty;
-    private checkPropertyValue;
-    private validatePrimitiveType;
-    private validateString;
-    private validateNumber;
-    private checkAdditionalProperties;
-    /**
-     * Checks if the given property is allowed on the given object.
-     * @param path The path of the current object.
-     * @param key The key of a property to check.
-     * @param typedValue The current object.
-     * @param propertyDefinitions The property definitions of the current object.
-     */
-    private checkAdditionalProperty;
-    /**
-     * Checks the element for a primitive.
-     *
-     * FHIR elements with primitive data types are represented in two parts:
-     *   1) A JSON property with the name of the element, which has a JSON type of number, boolean, or string
-     *   2) a JSON property with _ prepended to the name of the element, which, if present, contains the value's id and/or extensions
-     *
-     * See: https://hl7.org/fhir/json.html#primitive
-     * @param path The path to the property
-     * @param key The key in the current typed value.
-     * @param typedValue The current typed value.
-     * @returns True if the primitive element is valid.
-     */
-    private checkPrimitiveElement;
-    private createIssue;
-}
 /**
  * Recursively checks for null values in an object.
  *

package/dist/types/search/details.d.ts

@@ -1,5 +1,6 @@
-import { ElementDefinition, SearchParameter } from '@medplum/fhirtypes';
-import { Atom } from '../fhirlexer';
+import { SearchParameter } from '@medplum/fhirtypes';
+import { Atom } from '../fhirlexer/parse';
+import { InternalSchemaElement } from '../typeschema/types';
 export declare enum SearchParameterType {
     BOOLEAN = "BOOLEAN",
     NUMBER = "NUMBER",
@@ -15,7 +16,7 @@ export declare enum SearchParameterType {
 export interface SearchParameterDetails {
     readonly columnName: string;
     readonly type: SearchParameterType;
-    readonly elementDefinitions?: ElementDefinition[];
+    readonly elementDefinitions?: InternalSchemaElement[];
     readonly array?: boolean;
 }
 /**

package/dist/types/types.d.ts

@@ -1,5 +1,6 @@
-import { Bundle, ElementDefinition, Reference, Resource, ResourceType, SearchParameter, StructureDefinition } from '@medplum/fhirtypes';
+import { Bundle, ElementDefinition, Reference, Resource, ResourceType, SearchParameter } from '@medplum/fhirtypes';
 import { SearchParameterDetails } from './search/details';
+import { InternalSchemaElement, InternalTypeSchema } from './typeschema/types';
 export interface TypedValue {
     readonly type: string;
     readonly value: any;
@@ -9,67 +10,67 @@ export interface TypedValue {
  * http://www.hl7.org/fhir/valueset-defined-types.html
  * The list here includes additions found from StructureDefinition resources.
  */
-export declare enum PropertyType {
-    Address = "Address",
-    Age = "Age",
-    Annotation = "Annotation",
-    Attachment = "Attachment",
-    BackboneElement = "BackboneElement",
-    CodeableConcept = "CodeableConcept",
-    Coding = "Coding",
-    ContactDetail = "ContactDetail",
-    ContactPoint = "ContactPoint",
-    Contributor = "Contributor",
-    Count = "Count",
-    DataRequirement = "DataRequirement",
-    Distance = "Distance",
-    Dosage = "Dosage",
-    Duration = "Duration",
-    Expression = "Expression",
-    Extension = "Extension",
-    HumanName = "HumanName",
-    Identifier = "Identifier",
-    MarketingStatus = "MarketingStatus",
-    Meta = "Meta",
-    Money = "Money",
-    Narrative = "Narrative",
-    ParameterDefinition = "ParameterDefinition",
-    Period = "Period",
-    Population = "Population",
-    ProdCharacteristic = "ProdCharacteristic",
-    ProductShelfLife = "ProductShelfLife",
-    Quantity = "Quantity",
-    Range = "Range",
-    Ratio = "Ratio",
-    Reference = "Reference",
-    RelatedArtifact = "RelatedArtifact",
-    SampledData = "SampledData",
-    Signature = "Signature",
-    SubstanceAmount = "SubstanceAmount",
-    SystemString = "http://hl7.org/fhirpath/System.String",
-    Timing = "Timing",
-    TriggerDefinition = "TriggerDefinition",
-    UsageContext = "UsageContext",
-    base64Binary = "base64Binary",
-    boolean = "boolean",
-    canonical = "canonical",
-    code = "code",
-    date = "date",
-    dateTime = "dateTime",
-    decimal = "decimal",
-    id = "id",
-    instant = "instant",
-    integer = "integer",
-    markdown = "markdown",
-    oid = "oid",
-    positiveInt = "positiveInt",
-    string = "string",
-    time = "time",
-    unsignedInt = "unsignedInt",
-    uri = "uri",
-    url = "url",
-    uuid = "uuid"
-}
+export declare const PropertyType: {
+    Address: string;
+    Age: string;
+    Annotation: string;
+    Attachment: string;
+    BackboneElement: string;
+    CodeableConcept: string;
+    Coding: string;
+    ContactDetail: string;
+    ContactPoint: string;
+    Contributor: string;
+    Count: string;
+    DataRequirement: string;
+    Distance: string;
+    Dosage: string;
+    Duration: string;
+    Expression: string;
+    Extension: string;
+    HumanName: string;
+    Identifier: string;
+    MarketingStatus: string;
+    Meta: string;
+    Money: string;
+    Narrative: string;
+    ParameterDefinition: string;
+    Period: string;
+    Population: string;
+    ProdCharacteristic: string;
+    ProductShelfLife: string;
+    Quantity: string;
+    Range: string;
+    Ratio: string;
+    Reference: string;
+    RelatedArtifact: string;
+    SampledData: string;
+    Signature: string;
+    SubstanceAmount: string;
+    SystemString: string;
+    Timing: string;
+    TriggerDefinition: string;
+    UsageContext: string;
+    base64Binary: string;
+    boolean: string;
+    canonical: string;
+    code: string;
+    date: string;
+    dateTime: string;
+    decimal: string;
+    id: string;
+    instant: string;
+    integer: string;
+    markdown: string;
+    oid: string;
+    positiveInt: string;
+    string: string;
+    time: string;
+    unsignedInt: string;
+    uri: string;
+    url: string;
+    uuid: string;
+};
 /**
  * An IndexedStructureDefinition is a lookup-optimized version of a StructureDefinition.
  *
@@ -96,7 +97,7 @@ export declare enum PropertyType {
  */
 export interface IndexedStructureDefinition {
     types: {
-        [resourceType: string]: TypeSchema;
+        [resourceType: string]: TypeInfo;
     };
 }
 /**
@@ -108,34 +109,14 @@ export interface IndexedStructureDefinition {
  *   3) Patient_Communication
  *   4) Patient_Link
  */
-export interface TypeSchema {
-    structureDefinition: StructureDefinition;
-    elementDefinition: ElementDefinition;
-    display: string;
-    properties: {
-        [name: string]: ElementDefinition;
-    };
+export interface TypeInfo {
     searchParams?: {
         [code: string]: SearchParameter;
     };
     searchParamsDetails?: {
         [code: string]: SearchParameterDetails;
     };
-    description?: string;
-    parentType?: string;
 }
-/**
- * Indexes a bundle of StructureDefinitions for faster lookup.
- * @param bundle A FHIR bundle StructureDefinition resources.
- * @see {@link IndexedStructureDefinition} for more details on indexed StructureDefinitions.
- */
-export declare function indexStructureDefinitionBundle(bundle: Bundle): void;
-/**
- * Indexes a StructureDefinition for fast lookup.
- * @param structureDefinition The original StructureDefinition.
- * @see {@link IndexedStructureDefinition} for more details on indexed StructureDefinitions.
- */
-export declare function indexStructureDefinition(structureDefinition: StructureDefinition): void;
 /**
  * Indexes a bundle of SearchParameter resources for faster lookup.
  * @param bundle A FHIR bundle SearchParameter resources.
@@ -161,25 +142,26 @@ export declare function buildTypeName(components: string[]): string;
  * @param typeSchema The type schema to check.
  * @returns True if the type schema is a non-abstract FHIR resource.
  */
-export declare function isResourceTypeSchema(typeSchema: TypeSchema): boolean;
+export declare function isResourceTypeSchema(typeSchema: InternalTypeSchema): boolean;
 /**
  * Returns an array of all resource types.
  * Note that this is based on globalSchema, and will only return resource types that are currently in memory.
  * @returns An array of all resource types.
  */
 export declare function getResourceTypes(): ResourceType[];
-/**
- * Returns the type schema for the resource type.
- * @param resourceType The resource type.
- * @returns The type schema for the resource type.
- */
-export declare function getResourceTypeSchema(resourceType: string): TypeSchema;
 /**
  * Returns the search parameters for the resource type indexed by search code.
  * @param resourceType The resource type.
  * @returns The search parameters for the resource type indexed by search code.
  */
 export declare function getSearchParameters(resourceType: string): Record<string, SearchParameter> | undefined;
+/**
+ * Returns a search parameter for a resource type by search code.
+ * @param resourceType The FHIR resource type.
+ * @param code The search parameter code.
+ * @returns The search parameter if found, otherwise undefined.
+ */
+export declare function getSearchParameter(resourceType: string, code: string): SearchParameter | undefined;
 /**
  * Returns a human friendly display name for a FHIR element definition path.
  * @param path The FHIR element definition path.
@@ -193,7 +175,7 @@ export declare function getPropertyDisplayName(path: string): string;
  * @param propertyName The property name.
  * @returns The element definition if found.
  */
-export declare function getElementDefinition(typeName: string, propertyName: string): ElementDefinition | undefined;
+export declare function getElementDefinition(typeName: string, propertyName: string): InternalSchemaElement | undefined;
 /**
  * Typeguard to validate that an object is a FHIR resource
  * @param value The object to check