@medplum/fhirtypes 0.9.0 → 0.9.3

package/README.md

@@ -4,6 +4,8 @@ This library contains [TypeScript](https://www.typescriptlang.org/) type definit
 
 ## Installation
 
+Add as a dependency:
+
 ```bash
 npm install --save-dev @medplum/fhirtypes
 ```
@@ -12,7 +14,7 @@ npm install --save-dev @medplum/fhirtypes
 
 Consider the following untyped code:
 
-```typescript
+```ts
 const myPatient = {
   resourceType: 'Patient',
   name: 'George Washington',
@@ -23,7 +25,7 @@ Keen observers will note that `Patient.name` should not be a string. Instead, it
 
 Let's add the type definition and see what happens:
 
-```typescript
+```ts
 import { Patient } from '@medplum/fhirtypes';
 
 const myPatient: Patient = {
@@ -42,7 +44,7 @@ And now you will receive typeahead support:
 
 So we can build a well-formed example:
 
-```typescript
+```ts
 import { Patient } from '@medplum/fhirtypes';
 
 const myPatient: Patient = {
@@ -56,6 +58,10 @@ const myPatient: Patient = {
 };
 ```
 
+## About Medplum
+
+Medplum is a healthcare platform that helps you quickly develop high-quality compliant applications. Medplum includes a FHIR server, React component library, and developer app.
+
 ## License
 
 Apache 2.0. Copyright © Medplum 2022

package/dist/AccessPolicy.d.ts

@@ -72,10 +72,16 @@ export interface AccessPolicyResource {
   resourceType?: string;
 
   /**
-   * Optional compartment restriction for the resource type.
+   * DEPRECATED Optional compartment restriction for the resource type.
    */
   compartment?: Reference;
 
+  /**
+   * The rules that the server should use to determine which resources to
+   * allow.
+   */
+  criteria?: string;
+
   /**
    * Optional flag to indicate that the resource type is read-only.
    */

package/dist/DeviceDefinition.d.ts

@@ -5,6 +5,7 @@
 
 import { Annotation } from './Annotation';
 import { CodeableConcept } from './CodeableConcept';
+import { CodeableReference } from './CodeableReference';
 import { ContactPoint } from './ContactPoint';
 import { Extension } from './Extension';
 import { Identifier } from './Identifier';
@@ -15,6 +16,7 @@ import { ProdCharacteristic } from './ProdCharacteristic';
 import { ProductShelfLife } from './ProductShelfLife';
 import { Quantity } from './Quantity';
 import { Reference } from './Reference';
+import { RelatedArtifact } from './RelatedArtifact';
 import { Resource } from './Resource';
 
 /**
@@ -227,6 +229,17 @@ export interface DeviceDefinition {
    * made.
    */
   material?: DeviceDefinitionMaterial[];
+
+  /**
+   * What kind of device or device system this is.
+   */
+  classification?: DeviceDefinitionClassification[];
+
+  /**
+   * Indicates the anotomic location on the subject's body where the device
+   * was used ( i.e. the target).
+   */
+  bodySite?: CodeableReference;
 }
 
 /**
@@ -280,6 +293,58 @@ export interface DeviceDefinitionCapability {
   description?: CodeableConcept[];
 }
 
+/**
+ * What kind of device or device system this is.
+ */
+export interface DeviceDefinitionClassification {
+
+  /**
+   * Unique id for the element within a resource (for internal references).
+   * This may be any string value that does not contain spaces.
+   */
+  id?: string;
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the element. To make the use of extensions
+   * safe and manageable, there is a strict set of governance  applied to
+   * the definition and use of extensions. Though any implementer can
+   * define an extension, there is a set of requirements that SHALL be met
+   * as part of the definition of the extension.
+   */
+  extension?: Extension[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the element and that modifies the
+   * understanding of the element in which it is contained and/or the
+   * understanding of the containing element's descendants. Usually
+   * modifier elements provide negation or qualification. To make the use
+   * of extensions safe and manageable, there is a strict set of governance
+   * applied to the definition and use of extensions. Though any
+   * implementer can define an extension, there is a set of requirements
+   * that SHALL be met as part of the definition of the extension.
+   * Applications processing a resource are required to check for modifier
+   * extensions.
+   *
+   * Modifier extensions SHALL NOT change the meaning of any elements on
+   * Resource or DomainResource (including cannot change the meaning of
+   * modifierExtension itself).
+   */
+  modifierExtension?: Extension[];
+
+  /**
+   * A classification or risk class of the device model.
+   */
+  type?: CodeableConcept;
+
+  /**
+   * Further information qualifying this classification of the device
+   * model.
+   */
+  justification?: RelatedArtifact[];
+}
+
 /**
  * A name given to the device to identify it.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medplum/fhirtypes",
-  "version": "0.9.0",
+  "version": "0.9.3",
   "description": "Medplum FHIR Type Definitions",
   "author": "Medplum <hello@medplum.com>",
   "license": "Apache-2.0",