@smile-cdr/fhirts 2.2.8 → 2.4.0

package/dist/library/ResourceUtils/ResourceUtils.d.ts

@@ -1,4 +1,4 @@
-import { CodingKeys, IdentifierKeys } from "../dataTypes";
+import { CodingKeys, IdentifierKeys } from '../dataTypes';
 export declare class ResourceUtils {
     /**
      *
@@ -7,38 +7,46 @@ export declare class ResourceUtils {
      * @returns json property if it exists
      * @limitation currently just supports get for top level property on resource
      */
-    getResourceProperty(inputJson: object, propertyName: string): any;
+    getResourceProperty(inputJson: Record<string, any>, propertyName: string): any;
     /**
+     * Get identifiers from a list filtered by property value
      *
+     * @template T - The identifier type to return (defaults to any for backward compatibility)
      * @param identifierList list of identifiers
      * @param propertyToCompare identifier property to compare
      * @param propertyValue value we want to compare against
      * @returns array of matches
      * @limitations currently does not work with identifier.type, identifier.period & identifier.assigner
      */
-    getIdentifiersByProperty(identifierList: any[], propertyToCompare: IdentifierKeys, propertyValue: any[IdentifierKeys]): any[];
+    getIdentifiersByProperty<T = any>(identifierList: any[] | null, propertyToCompare: IdentifierKeys, propertyValue: any[IdentifierKeys]): T[];
     /**
+     * Get extensions from a list filtered by URL
      *
+     * @template T - The extension type to return (defaults to any for backward compatibility)
      * @param extensionList list of extensions
      * @param extensionUrl Extension.url to compare
      * @returns array of matches
      */
-    getExtensionsByUrl(extensionList: any[], extensionUrl: string): any[];
+    getExtensionsByUrl<T = any>(extensionList: any[] | null, extensionUrl: string): T[];
     /**
+     * Get codings from a list filtered by property value
      *
+     * @template T - The coding type to return (defaults to any for backward compatibility)
      * @param codingList list of codings
      * @param propertyToCompare coding property to compare
      * @param propertyValue value we want to compare against string or boolean
      * @returns array of matches
      */
-    getCodingsByProperty(codingList: any[], propertyToCompare: CodingKeys, propertyValue: any[CodingKeys]): any[];
+    getCodingsByProperty<T = any>(codingList: any[] | null, propertyToCompare: CodingKeys, propertyValue: any[CodingKeys]): T[];
     /**
+     * Get values at a specific path in a FHIR resource
      *
+     * @template T - The value type to return (defaults to any for backward compatibility)
      * @param resource resource for which path needs to be validated
-     * @param elementPath path to validate in resource
+     * @param elementPath path to validate in resource (e.g., "Patient.name.given")
      * @returns array of elements found at the provided path
      */
-    getValuesAtResourcePath(resource: any, elementPath: string): any[];
+    getValuesAtResourcePath<T = any>(resource: any, elementPath: string): T[];
     private getValuesAtResourcePathInner;
     private isPrimitive;
     /**

package/dist/library/ResourceUtils/ResourceUtils.js

@@ -11,13 +11,15 @@ class ResourceUtils {
      */
     getResourceProperty(inputJson, propertyName) {
         let resourcePropertyValue = null;
-        if (inputJson.hasOwnProperty(propertyName)) {
+        if (Object.prototype.hasOwnProperty.call(inputJson, propertyName)) {
             resourcePropertyValue = inputJson[propertyName];
         }
         return resourcePropertyValue;
     }
     /**
+     * Get identifiers from a list filtered by property value
      *
+     * @template T - The identifier type to return (defaults to any for backward compatibility)
      * @param identifierList list of identifiers
      * @param propertyToCompare identifier property to compare
      * @param propertyValue value we want to compare against
@@ -30,18 +32,20 @@ class ResourceUtils {
             : [];
     }
     /**
+     * Get extensions from a list filtered by URL
      *
+     * @template T - The extension type to return (defaults to any for backward compatibility)
      * @param extensionList list of extensions
      * @param extensionUrl Extension.url to compare
      * @returns array of matches
      */
     getExtensionsByUrl(extensionList, extensionUrl) {
-        return (extensionList === null || extensionList === void 0 ? void 0 : extensionList.length)
-            ? extensionList.filter((x) => x["url"] === extensionUrl)
-            : [];
+        return (extensionList === null || extensionList === void 0 ? void 0 : extensionList.length) ? extensionList.filter((x) => x['url'] === extensionUrl) : [];
     }
     /**
+     * Get codings from a list filtered by property value
      *
+     * @template T - The coding type to return (defaults to any for backward compatibility)
      * @param codingList list of codings
      * @param propertyToCompare coding property to compare
      * @param propertyValue value we want to compare against string or boolean
@@ -53,28 +57,32 @@ class ResourceUtils {
             : [];
     }
     /**
+     * Get values at a specific path in a FHIR resource
      *
+     * @template T - The value type to return (defaults to any for backward compatibility)
      * @param resource resource for which path needs to be validated
-     * @param elementPath path to validate in resource
+     * @param elementPath path to validate in resource (e.g., "Patient.name.given")
      * @returns array of elements found at the provided path
      */
     getValuesAtResourcePath(resource, elementPath) {
         const pathSections = elementPath.split('.');
-        if (!resource || (resource.resourceType !== pathSections[0]))
+        if (!resource || resource.resourceType !== pathSections[0]) {
             return [];
+        }
         return this.getValuesAtResourcePathInner(resource, pathSections);
     }
     getValuesAtResourcePathInner(resource, pathSections) {
+        var _a;
         let resourcePathValue;
         for (let index = 1; index < pathSections.length; index++) {
-            const subPaths = pathSections[index];
+            const subPaths = (_a = pathSections[index]) !== null && _a !== void 0 ? _a : '';
             resourcePathValue = resourcePathValue ? resourcePathValue[subPaths] : resource[subPaths];
             if (resourcePathValue) {
                 if (this.isPrimitive(resourcePathValue) || pathSections.length === 2) {
                     return Array.isArray(resourcePathValue) ? [...resourcePathValue] : [resourcePathValue];
                 }
                 else if (Array.isArray(resourcePathValue) && resourcePathValue.length > 0) {
-                    let resultSet = [];
+                    const resultSet = [];
                     for (let subPathIndex = 0; subPathIndex < resourcePathValue.length; subPathIndex++) {
                         const subPathValue = resourcePathValue[subPathIndex];
                         if (this.isPrimitive(subPathValue)) {
@@ -86,7 +94,7 @@ class ResourceUtils {
                     }
                     return resultSet;
                 }
-                else if (typeof (resourcePathValue) === 'object') {
+                else if (typeof resourcePathValue === 'object') {
                     return this.getValuesAtResourcePathInner(resourcePathValue, pathSections.slice(index));
                 }
             }
@@ -97,7 +105,7 @@ class ResourceUtils {
         return [];
     }
     isPrimitive(value) {
-        return typeof (value) === "boolean" || typeof (value) === "string";
+        return typeof value === 'boolean' || typeof value === 'string';
     }
     /**
      * @param resource resource to pull out references from
@@ -106,7 +114,7 @@ class ResourceUtils {
     getAllReferencesFromResource(resource) {
         const stringifiedResource = JSON.stringify(resource);
         const referenceJsonString = '"reference":';
-        let references = [];
+        const references = [];
         let cursor = stringifiedResource.indexOf(referenceJsonString, 0);
         while (cursor > -1) {
             const referenceStart = stringifiedResource.indexOf(referenceJsonString, cursor) + referenceJsonString.length;

package/dist/library/ResourceUtils/ResourceUtils.spec.js

@@ -1,289 +1,300 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ResourceUtils_1 = require("./ResourceUtils");
-const patientPayload = require("./../../test-resources/Patient-R4.json");
-const careTeamPayload = require("./../../test-resources/CareTeam-R4.json");
-describe("ResourceUtils", () => {
-    let resourceUtils = new ResourceUtils_1.ResourceUtils();
-    describe("#getResourceProperty()", () => {
-        it("should return property if property exists in valid inputJson", () => {
+const patientPayload = require('./../../test-resources/Patient-R4.json');
+const careTeamPayload = require('./../../test-resources/CareTeam-R4.json');
+const careTeamContainedPayload = require('./../../test-resources/CareTeam-R4-contained.json');
+describe('ResourceUtils', () => {
+    const resourceUtils = new ResourceUtils_1.ResourceUtils();
+    describe('#getResourceProperty()', () => {
+        it('should return property if property exists in valid inputJson', () => {
             // execute
-            const actual = resourceUtils.getResourceProperty(patientPayload, "deceasedBoolean");
+            const actual = resourceUtils.getResourceProperty(patientPayload, 'deceasedBoolean');
             // validate
             expect(actual).toBeFalse();
         });
-        it("should return null if property exists in valid inputJson", () => {
+        it('should return null if property exists in valid inputJson', () => {
             // execute
-            const actual = resourceUtils.getResourceProperty(patientPayload, "abcd");
+            const actual = resourceUtils.getResourceProperty(patientPayload, 'abcd');
             // validate
             expect(actual).toBeNull();
         });
-        it("should return null if invalid inputJson is passed", () => {
+        it('should return null if invalid inputJson is passed', () => {
             // setup
             const inputPayload = [1, 2];
             // execute
-            const actual = resourceUtils.getResourceProperty(inputPayload, "deceasedBoolean");
+            const actual = resourceUtils.getResourceProperty(inputPayload, 'deceasedBoolean');
             // validate
             expect(actual).toBeNull();
         });
     });
-    describe("#getIdentifiersByProperty()", () => {
+    describe('#getIdentifiersByProperty()', () => {
         const identifierList = [
             {
-                use: "temp",
-                system: "http://hl7.org/fhir/sid/us-ssn",
-                value: "abc",
+                use: 'temp',
+                system: 'http://hl7.org/fhir/sid/us-ssn',
+                value: 'abc',
             },
             {
-                use: "usual",
-                system: "http://ns.electronichealth.net.au/id/hi/ihi/1.0",
-                value: "abc",
+                use: 'usual',
+                system: 'http://ns.electronichealth.net.au/id/hi/ihi/1.0',
+                value: 'abc',
             },
         ];
-        it("should return empty array if null is passed as identifier list", () => {
+        it('should return empty array if null is passed as identifier list', () => {
             // setup
-            const value = "shouldBeIgnored";
+            const value = 'shouldBeIgnored';
             // execute
-            const actual = resourceUtils.getIdentifiersByProperty(null, "id", value);
+            const actual = resourceUtils.getIdentifiersByProperty(null, 'id', value);
             // validate
             expect(actual.length).toEqual(0);
         });
-        it("should return empty array if property not found", () => {
+        it('should return empty array if property not found', () => {
             // setup
-            const value = "abc";
+            const value = 'abc';
             // execute
-            const actual = resourceUtils.getIdentifiersByProperty(identifierList, "extension", // no extensions in test data
+            const actual = resourceUtils.getIdentifiersByProperty(identifierList, 'extension', // no extensions in test data
             value);
             // validate
             expect(actual.length).toEqual(0);
         });
-        it("should return empty array if no matches found", () => {
+        it('should return empty array if no matches found', () => {
             // setup
-            const systemUrl = "http://somesystem.com";
+            const systemUrl = 'http://somesystem.com';
             // execute
-            const actual = resourceUtils.getIdentifiersByProperty(identifierList, "system", systemUrl);
+            const actual = resourceUtils.getIdentifiersByProperty(identifierList, 'system', systemUrl);
             // validate
             expect(actual.length).toEqual(0);
         });
-        it("should return array with all matches", () => {
+        it('should return array with all matches', () => {
             // setup
-            const value = "abc";
+            const value = 'abc';
             // execute
-            const actual = resourceUtils.getIdentifiersByProperty(identifierList, "value", value);
+            const actual = resourceUtils.getIdentifiersByProperty(identifierList, 'value', value);
             // validate
             expect(actual.length).toEqual(2);
         });
     });
-    describe("#getExtensionsByUrl()", () => {
+    describe('#getExtensionsByUrl()', () => {
         const extensionList = [
             {
-                url: "http://hl7.org/fhir/sid/us-ssn",
+                url: 'http://hl7.org/fhir/sid/us-ssn',
                 valueBoolean: true,
             },
             {
-                url: "http://ns.electronichealth.net.au/id/hi/ihi/1.0",
-                valueString: "abc",
+                url: 'http://ns.electronichealth.net.au/id/hi/ihi/1.0',
+                valueString: 'abc',
             },
         ];
-        it("should return empty array if null is passed as extension list", () => {
+        it('should return empty array if null is passed as extension list', () => {
             // execute
-            const actual = resourceUtils.getExtensionsByUrl(null, "url");
+            const actual = resourceUtils.getExtensionsByUrl(null, 'url');
             // validate
             expect(actual.length).toEqual(0);
         });
-        it("should return empty array if invalid extension array passed", () => {
+        it('should return empty array if invalid extension array passed', () => {
             // setup
             const extensionListInvalid = [
                 {
                     // @ts-ignore
-                    use: "temp",
-                    system: "http://hl7.org/fhir/sid/us-ssn",
-                    value: "abc",
+                    use: 'temp',
+                    system: 'http://hl7.org/fhir/sid/us-ssn',
+                    value: 'abc',
                 },
             ]; // disabling compiler warning for the test
-            const url = "http://ns.electronichealth.net.au/id/hi/ihi/1.0";
+            const url = 'http://ns.electronichealth.net.au/id/hi/ihi/1.0';
             // execute
             const actual = resourceUtils.getExtensionsByUrl(extensionListInvalid, url);
             // validate
             expect(actual.length).toEqual(0);
         });
-        it("should return empty array if no matches found", () => {
+        it('should return empty array if no matches found', () => {
             // setup
-            const url = "http://somesystem.com";
+            const url = 'http://somesystem.com';
             // execute
             const actual = resourceUtils.getExtensionsByUrl(extensionList, url);
             // validate
             expect(actual.length).toEqual(0);
         });
-        it("should return array with all matches", () => {
+        it('should return array with all matches', () => {
             // setup
-            const url = "http://ns.electronichealth.net.au/id/hi/ihi/1.0";
+            const url = 'http://ns.electronichealth.net.au/id/hi/ihi/1.0';
             // execute
             const actual = resourceUtils.getExtensionsByUrl(extensionList, url);
             // validate
             expect(actual.length).toEqual(1);
         });
     });
-    describe("#getCodingsByProperty()", () => {
+    describe('#getCodingsByProperty()', () => {
         const codingList = [
             {
-                version: "1.0",
-                system: "http://hl7.org/fhir/sid/us-ssn",
-                code: "abc",
-                display: "abc",
+                version: '1.0',
+                system: 'http://hl7.org/fhir/sid/us-ssn',
+                code: 'abc',
+                display: 'abc',
                 userSelected: false,
             },
             {
-                version: "1.1",
-                system: "http://ns.electronichealth.net.au/id/hi/ihi/1.0",
-                code: "abc",
-                display: "abc",
+                version: '1.1',
+                system: 'http://ns.electronichealth.net.au/id/hi/ihi/1.0',
+                code: 'abc',
+                display: 'abc',
             },
         ];
-        it("should return empty array if null is passed as coding list", () => {
+        it('should return empty array if null is passed as coding list', () => {
             // setup
-            const value = "shouldBeIgnored";
+            const value = 'shouldBeIgnored';
             // execute
-            const actual = resourceUtils.getCodingsByProperty(null, "extension", value);
+            const actual = resourceUtils.getCodingsByProperty(null, 'extension', value);
             // validate
             expect(actual.length).toEqual(0);
         });
-        it("should return empty array if property not found", () => {
+        it('should return empty array if property not found', () => {
             // setup
-            const value = "abc";
+            const value = 'abc';
             // execute
-            const actual = resourceUtils.getCodingsByProperty(codingList, "id", // expect no ID in codingList
+            const actual = resourceUtils.getCodingsByProperty(codingList, 'id', // expect no ID in codingList
             value);
             // validate
             expect(actual.length).toEqual(0);
         });
-        it("should return empty array if no matches found", () => {
+        it('should return empty array if no matches found', () => {
             // setup
-            const systemUrl = "http://somesystem.com";
+            const systemUrl = 'http://somesystem.com';
             // execute
-            const actual = resourceUtils.getCodingsByProperty(codingList, "system", systemUrl);
+            const actual = resourceUtils.getCodingsByProperty(codingList, 'system', systemUrl);
             // validate
             expect(actual.length).toEqual(0);
         });
-        it("should return array with all matches for string values", () => {
+        it('should return array with all matches for string values', () => {
             // setup
-            const value = "abc";
+            const value = 'abc';
             // execute
-            const actual = resourceUtils.getCodingsByProperty(codingList, "code", value);
+            const actual = resourceUtils.getCodingsByProperty(codingList, 'code', value);
             // validate
             expect(actual.length).toEqual(2);
         });
-        it("should return array with all matches for boolean values", () => {
+        it('should return array with all matches for boolean values', () => {
             // setup
             const value = false;
             // execute
-            const actual = resourceUtils.getCodingsByProperty(codingList, "userSelected", value);
+            const actual = resourceUtils.getCodingsByProperty(codingList, 'userSelected', value);
             // validate
             expect(actual.length).toEqual(1);
         });
     });
-    describe("#getValuesAtResourcePath()", () => {
-        it("should return empty array if the root of the path path does not match the resource type", () => {
+    describe('#getValuesAtResourcePath()', () => {
+        it('should return empty array if the root of the path path does not match the resource type', () => {
             // execute
-            const pathValues = resourceUtils.getValuesAtResourcePath(patientPayload, "Practitioner.name.given");
+            const pathValues = resourceUtils.getValuesAtResourcePath(patientPayload, 'Practitioner.name.given');
             // validate
             expect(pathValues.length).toEqual(0);
         });
-        it("should return array with values if path exists for a top level element", () => {
+        it('should return array with values if path exists for a top level element', () => {
             // execute
-            const pathValues = resourceUtils.getValuesAtResourcePath(patientPayload, "Patient.gender");
+            const pathValues = resourceUtils.getValuesAtResourcePath(patientPayload, 'Patient.gender');
             // validate
             expect(pathValues.length).toEqual(1);
-            expect(pathValues[0]).toEqual("male");
+            expect(pathValues[0]).toEqual('male');
         });
         it('should return array with values if path exists for a top level element and is an object', () => {
             const expected = [
                 {
                     coding: [
                         {
-                            system: "http://terminology.hl7.org/CodeSystem/v3-MaritalStatus",
-                            code: "M",
-                            display: "Married"
-                        }
+                            system: 'http://terminology.hl7.org/CodeSystem/v3-MaritalStatus',
+                            code: 'M',
+                            display: 'Married',
+                        },
                     ],
-                    text: "Getrouwd",
-                }
+                    text: 'Getrouwd',
+                },
             ];
             // execute
-            const actual = resourceUtils.getValuesAtResourcePath(patientPayload, "Patient.maritalStatus");
+            const actual = resourceUtils.getValuesAtResourcePath(patientPayload, 'Patient.maritalStatus');
             // validate
             expect(actual.length).toEqual(1);
             expect(actual).toEqual(expected);
         });
-        it("should return array with values if path exists for a top level element and is an array", () => {
+        it('should return array with values if path exists for a top level element and is an array', () => {
             // setup
             const expected = [
                 {
-                    use: "usual",
-                    family: "van de Heuvel",
-                    given: ["Pieter", "Peter"],
-                    suffix: ["MSc"],
+                    use: 'usual',
+                    family: 'van de Heuvel',
+                    given: ['Pieter', 'Peter'],
+                    suffix: ['MSc'],
                 },
                 {
-                    use: "usual",
-                    family: "van de Heuvel",
-                    given: ["Pieter"],
-                    suffix: ["MSc"],
+                    use: 'usual',
+                    family: 'van de Heuvel',
+                    given: ['Pieter'],
+                    suffix: ['MSc'],
                 },
             ];
             // execute
-            const actual = resourceUtils.getValuesAtResourcePath(patientPayload, "Patient.name");
+            const actual = resourceUtils.getValuesAtResourcePath(patientPayload, 'Patient.name');
             // validate
             expect(actual.length).toEqual(2);
             expect(actual).toEqual(expected);
         });
-        it("should return array with values for a array under object", () => {
+        it('should return array with values for a array under object', () => {
             // execute
-            const pathValues = resourceUtils.getValuesAtResourcePath(patientPayload, "Patient.name.given");
+            const pathValues = resourceUtils.getValuesAtResourcePath(patientPayload, 'Patient.name.given');
             // validate
             expect(pathValues.length).toEqual(3);
-            expect(pathValues[0]).toEqual("Pieter");
-            expect(pathValues[1]).toEqual("Peter");
-            expect(pathValues[2]).toEqual("Pieter");
+            expect(pathValues[0]).toEqual('Pieter');
+            expect(pathValues[1]).toEqual('Peter');
+            expect(pathValues[2]).toEqual('Pieter');
         });
-        it("should return array with values if path exists for a deep array element", () => {
+        it('should return array with values if path exists for a deep array element', () => {
             // execute
-            const pathValues = resourceUtils.getValuesAtResourcePath(patientPayload, "Patient.contact.relationship.coding.system");
+            const pathValues = resourceUtils.getValuesAtResourcePath(patientPayload, 'Patient.contact.relationship.coding.system');
             // validate
             expect(pathValues.length).toEqual(2);
-            expect(pathValues[0]).toEqual("http://terminology.hl7.org/CodeSystem/v2-0131");
-            expect(pathValues[1]).toEqual("http://terminology.hl7.org/CodeSystem/v2-0132");
+            expect(pathValues[0]).toEqual('http://terminology.hl7.org/CodeSystem/v2-0131');
+            expect(pathValues[1]).toEqual('http://terminology.hl7.org/CodeSystem/v2-0132');
         });
-        it("should return array with values if path exists for a deep json element", () => {
+        it('should return array with values if path exists for a deep json element', () => {
             // execute
-            const pathValues = resourceUtils.getValuesAtResourcePath(patientPayload, "Patient.maritalStatus.coding.system");
+            const pathValues = resourceUtils.getValuesAtResourcePath(patientPayload, 'Patient.maritalStatus.coding.system');
             // validate
             expect(pathValues.length).toEqual(1);
-            expect(pathValues[0]).toEqual("http://terminology.hl7.org/CodeSystem/v3-MaritalStatus");
+            expect(pathValues[0]).toEqual('http://terminology.hl7.org/CodeSystem/v3-MaritalStatus');
         });
-        it("should return empty array if path does not exist", () => {
+        it('should return empty array if path does not exist', () => {
             // execute
-            const pathValues = resourceUtils.getValuesAtResourcePath(patientPayload, "Patient.contact.relationship.coding.abcd");
+            const pathValues = resourceUtils.getValuesAtResourcePath(patientPayload, 'Patient.contact.relationship.coding.abcd');
             // validate
             expect(pathValues.length).toEqual(0);
         });
     });
-    describe("#getAllResourceReferences()", () => {
-        it("should return array of all references in a resource when references found", () => {
+    describe('#getAllResourceReferences()', () => {
+        it('should return array of all references in a resource when references found', () => {
             // execute
             const actual = resourceUtils.getAllReferencesFromResource(careTeamPayload);
             // validate
             expect(actual.length).toEqual(6);
         });
-        it("should return empty array if references in a resource not found", () => {
+        it('should return empty array if references in a resource not found', () => {
             // setup
             const input = {
-                "resourceType": "Patient"
+                resourceType: 'Patient',
             };
             // execute
             const actual = resourceUtils.getAllReferencesFromResource(input);
             // validate
             expect(actual.length).toEqual(0);
         });
+        it('should return array of all references in a resource when references found in contained resource', () => {
+            var _a;
+            // setup
+            const input = careTeamContainedPayload;
+            expect(input.contained).toHaveSize(1);
+            // execute
+            const actual = resourceUtils.getAllReferencesFromResource((_a = input.contained) === null || _a === void 0 ? void 0 : _a[0]);
+            // validate
+            expect(actual.length).toEqual(1);
+        });
     });
 });

package/dist/library/constants.js

@@ -5,7 +5,7 @@ var SORT_ORDER;
 (function (SORT_ORDER) {
     SORT_ORDER[SORT_ORDER["ASCENDING"] = 0] = "ASCENDING";
     SORT_ORDER[SORT_ORDER["DESCENDING"] = 1] = "DESCENDING";
-})(SORT_ORDER = exports.SORT_ORDER || (exports.SORT_ORDER = {}));
+})(SORT_ORDER || (exports.SORT_ORDER = SORT_ORDER = {}));
 var PATCH_DATATYPE;
 (function (PATCH_DATATYPE) {
     PATCH_DATATYPE["CODE"] = "valueCode";
@@ -19,4 +19,4 @@ var PATCH_DATATYPE;
     PATCH_DATATYPE["STRING"] = "valueString";
     PATCH_DATATYPE["ADDRESS"] = "valueAddress";
     PATCH_DATATYPE["REFERENCE"] = "valueReference";
-})(PATCH_DATATYPE = exports.PATCH_DATATYPE || (exports.PATCH_DATATYPE = {}));
+})(PATCH_DATATYPE || (exports.PATCH_DATATYPE = PATCH_DATATYPE = {}));

package/dist/library/dataTypes.d.ts

@@ -1,9 +1,9 @@
-import { fhirR5 } from "..";
-import * as DSTU2 from "../FHIR-DSTU2";
-import * as fhirR3 from "../FHIR-R3";
-import { Coding as r4Coding } from "../FHIR-R4/classes/coding";
-import { Extension as r4Extension } from "../FHIR-R4/classes/extension";
-import { Identifier as r4Identifier } from "../FHIR-R4/classes/identifier";
+import { fhirR5 } from '..';
+import * as DSTU2 from '../FHIR-DSTU2';
+import * as fhirR3 from '../FHIR-R3';
+import { Coding as r4Coding } from '../FHIR-R4/classes/coding';
+import { Extension as r4Extension } from '../FHIR-R4/classes/extension';
+import { Identifier as r4Identifier } from '../FHIR-R4/classes/identifier';
 export type Identifier = r4Identifier & fhirR3.Identifier & DSTU2.Identifier & fhirR5.Identifier;
 export type IdentifierKeys = keyof Identifier;
 export type Extension = r4Extension & fhirR3.Extension & DSTU2.Extension & fhirR5.Extension;