FHIR Types

Usage

The FHIR types are split up into a few different files, resources, datatypes, metadatatypes, valuesets, and extensions.

import type {...} from '@azaleahealth/azalea-kit-ui/fhir/resources';

        
  
        
      

import type Communication, {
  CommunicationExtensionReadFlag
} from '@azaleahealth/azalea-kit-ui/fhir/resources/Communication';

        
  
        
      

import type {...} from '@azaleahealth/azalea-kit-ui/fhir/datatypes';

        
  
        
      

import type {...} from '@azaleahealth/azalea-kit-ui/fhir/metadatatypes';

        
  
        
      

import type { ValueSets } from '@azaleahealth/azalea-kit-ui/fhir/valuesets';

        
  
        
      

import type { TextExtension } from '@azaleahealth/azalea-kit-ui/fhir/extensions';

        
  
        
      

Example

import type { Bundle, DocumentReference } from '@azaleahealth/azalea-kit-ui/fhir/resources';
import type { ValueSets } from '@azaleahealth/azalea-kit-ui/fhir/valuesets';

// We can use the DocumentReferenceStatus value set here to make sure only valid statuses are used
async function getDocuments(status: ValueSets.DocumentReferenceStatus): Promise<Bundle<DocumentReference>> {
  const documentsResponse = await fetch(
    'example.com/my/fhir/server/DocumentReference?' + new URLSearchParams({ status }).toString(),
    {
      method: 'GET',
      headers: {
        Accept: 'application/fhir+json',
        Authorization: 'your-auth-token-here'
      }
    }
  );

  const documentBundle = await documentsResponse.json();

  // We know that the endpoint we fetched should return a Bundle of DocumentReferences
  return documentBundle as Bundle<DocumentReference>;
}

        
  
        
      

Generic Types

Some of our types are defined as generic for ease of use.

Bundle

The Bundle resource can take a type argument to define the expected resource type contained in its entries.

// allergies-api.ts
import { AllergyIntolerance, Bundle } from './fhir/resources';

function searchAllergies(): Bundle<AllergyIntolerance> {
  //...
}

// Will be typed as AllergyIntolerance
const firstAllergy = searchAllergies().entry?.[0]?.resource;

        
  
        
      

Parameters

The Parameters resource can take a type argument to define the expected value[x] key and type.

import type { Address } from '@azaleahealth/azalea-kit-ui/fhir/datatypes';
import type { Parameters } from '@azaleahealth/azalea-kit-ui/fhir/resources';

const param: Parameters<{ valueAddress: Address }> = {
  parameter: [
    {
      name: 'address',
      valueAddress: {/* ... */}
    }
  ]
};

        
  
        
      

Coding and CodeableConcept

The Coding datatype can take a type argument to define the expected possible values of Coding.code. CodeableConcept will pass its type argument on to its code property (which is of type Coding[]).

import { CodeableConcept, Coding } from '@azaleahealth/azalea-kit-ui/fhir/datatypes';
import { ValueSets } from '@azaleahealth/azalea-kit-ui/fhir/valuesets';

const appointmentStatusCoding: Coding<ValueSets.AppointmentStatus> = { code: 'arrived' };

const bundleTypeCodeable: CodeableConcept<ValueSets.BundleType> = { coding: [] };

// type error here!
bundleTypeCodeable.coding?.push(appointmentStatusCoding);

        
  
        
      

Choice-of Properties

Choice-of properties (notated as nnn[x] in the FHIR documentation) at the top level cannot be perfectly implemented due to the limitations of TypeScript. Instead, they have been implemented as optional properties regardless of the cardinality of the choice-of property they represent and are documented with the name and cardinality of said property.

For example, the Annotation datatype has a property author[x] and is defined as

export interface Annotation extends Element {
  /** author[x] 0..1 Reference(Practitioner | Patient | RelatedPerson | Organization) */
  authorReference: Reference;
  /** author[x] 0..1 */
  authorString: string;
  /** dateTime */
  time?: string;
  /** markdown */
  text: string;
}

        
  
        
      

For choice-of properties not at the top level, such as Dosage.dosageAndRate[0].rate[x] we are able to properly represent the mutual exclusivity of the properties in TypeScript.

Quantity Variants

The Quantity data type has a few variants that cannot be meaningfully represented in TypeScript, and as such we have elected not to include them. These are Distance, Age, Count, and Duration. Instead we have treated properties of these types as we do primitive types, by typing them as Quantity and including a doc comment with the more specific type.

Reporting Issues and Requesting Features

If you have found an issue with the FHIR types or would like to request a missing type be added, please open a ticket in JIRA in the Azalea Kit UI project assigned to Connor Dooley. Please include a link to the relevant FHIR documentation and a description of what you would like added or the discrepancy between the official documentation and the TypeScript implementation.