@medplum/fhirtypes 3.1.3 → 3.1.5

package/dist/AccessPolicy.d.ts

@@ -4,8 +4,11 @@
  */
 
 import { Expression } from './Expression';
+import { Extension } from './Extension';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
 import { Reference } from './Reference';
+import { Resource } from './Resource';
 
 /**
  * Access Policy for user or user group that defines how entities can or
@@ -44,6 +47,51 @@ export interface AccessPolicy {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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 name associated with the AccessPolicy.
    */
@@ -104,7 +152,7 @@ export interface AccessPolicyResource {
   resourceType: string;
 
   /**
-   * DEPRECATED Optional compartment restriction for the resource type.
+   * @deprecated Optional compartment restriction for the resource type.
    */
   compartment?: Reference;
 

package/dist/Agent.d.ts

@@ -6,9 +6,12 @@
 import { Bot } from './Bot';
 import { Device } from './Device';
 import { Endpoint } from './Endpoint';
+import { Extension } from './Extension';
 import { Identifier } from './Identifier';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
 import { Reference } from './Reference';
+import { Resource } from './Resource';
 
 /**
  * Configuration details for an instance of the Medplum agent
@@ -47,6 +50,51 @@ export interface Agent {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * An identifier for this agent.
    */

package/dist/AsyncJob.d.ts

@@ -3,7 +3,11 @@
  * Do not edit manually.
  */
 
+import { Extension } from './Extension';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
+import { Parameters } from './Parameters';
+import { Resource } from './Resource';
 
 /**
  * Contains details of long running asynchronous/background jobs.
@@ -41,6 +45,51 @@ export interface AsyncJob {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * The status of the request.
    */
@@ -64,4 +113,9 @@ export interface AsyncJob {
    * request, this URL will not include the request parameters.
    */
   request: string;
+
+  /**
+   * Outputs resulting from the async job.
+   */
+  output?: Parameters;
 }

package/dist/Bot.d.ts

@@ -5,8 +5,11 @@
 
 import { Attachment } from './Attachment';
 import { CodeableConcept } from './CodeableConcept';
+import { Extension } from './Extension';
 import { Identifier } from './Identifier';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
+import { Resource } from './Resource';
 import { Timing } from './Timing';
 
 /**
@@ -45,6 +48,51 @@ export interface Bot {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * An identifier for this bot.
    */
@@ -117,7 +165,7 @@ export interface Bot {
   executableCode?: Attachment;
 
   /**
-   * DEPRECATED Bot logic script. Use Bot.sourceCode or Bot.executableCode
+   * @deprecated Bot logic script. Use Bot.sourceCode or Bot.executableCode
    * instead.
    */
   code?: string;

package/dist/BulkDataExport.d.ts

@@ -3,7 +3,10 @@
  * Do not edit manually.
  */
 
+import { Extension } from './Extension';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
+import { Resource } from './Resource';
 import { ResourceType } from './ResourceType';
 
 /**
@@ -42,6 +45,51 @@ export interface BulkDataExport {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * The status of the request.
    */

package/dist/ClientApplication.d.ts

@@ -3,8 +3,11 @@
  * Do not edit manually.
  */
 
+import { Extension } from './Extension';
 import { IdentityProvider } from './IdentityProvider';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
+import { Resource } from './Resource';
 
 /**
  * Medplum client application for automated access.
@@ -42,6 +45,51 @@ export interface ClientApplication {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * The client application status. The status is active by default. The
    * status can be set to error to indicate that the client application is

package/dist/DomainConfiguration.d.ts

@@ -3,8 +3,11 @@
  * Do not edit manually.
  */
 
+import { Extension } from './Extension';
 import { IdentityProvider } from './IdentityProvider';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
+import { Resource } from './Resource';
 
 /**
  * Domain specific configuration for the Medplum application.
@@ -42,6 +45,51 @@ export interface DomainConfiguration {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * Globally unique domain name for this configuration.
    */

package/dist/JsonWebKey.d.ts

@@ -3,7 +3,10 @@
  * Do not edit manually.
  */
 
+import { Extension } from './Extension';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
+import { Resource } from './Resource';
 
 /**
  * A JSON object that represents a cryptographic key. The members of the
@@ -42,6 +45,51 @@ export interface JsonWebKey {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * Whether this key is in active use.
    */

package/dist/Login.d.ts

@@ -5,10 +5,13 @@
 
 import { Bot } from './Bot';
 import { ClientApplication } from './ClientApplication';
+import { Extension } from './Extension';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
 import { Project } from './Project';
 import { ProjectMembership } from './ProjectMembership';
 import { Reference } from './Reference';
+import { Resource } from './Resource';
 import { ResourceType } from './ResourceType';
 import { SmartAppLaunch } from './SmartAppLaunch';
 import { User } from './User';
@@ -49,6 +52,51 @@ export interface Login {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * The client requesting the code.
    */

package/dist/PasswordChangeRequest.d.ts

@@ -3,13 +3,16 @@
  * Do not edit manually.
  */
 
+import { Extension } from './Extension';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
 import { Reference } from './Reference';
+import { Resource } from './Resource';
 import { User } from './User';
 
 /**
- * DEPRECATED Password change request for the 'forgot password' flow. Use
- * UserSecurityCheck instead.
+ * @deprecated Password change request for the 'forgot password' flow.
+ * Use UserSecurityCheck instead.
  */
 export interface PasswordChangeRequest {
 
@@ -44,6 +47,51 @@ export interface PasswordChangeRequest {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * The type of password change request (invite or reset).
    */

package/dist/Project.d.ts

@@ -4,9 +4,12 @@
  */
 
 import { AccessPolicy } from './AccessPolicy';
+import { Extension } from './Extension';
 import { Identifier } from './Identifier';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
 import { Reference } from './Reference';
+import { Resource } from './Resource';
 import { User } from './User';
 
 /**
@@ -45,6 +48,51 @@ export interface Project {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * An identifier for this project.
    */
@@ -94,10 +142,28 @@ export interface Project {
   defaultPatientAccessPolicy?: Reference<AccessPolicy>;
 
   /**
-   * Secure environment variable that can be used to store secrets for
-   * bots.
+   * Option or parameter that can be adjusted within the Medplum Project to
+   * customize its behavior.
    */
-  secret?: ProjectSecret[];
+  setting?: ProjectSetting[];
+
+  /**
+   * Option or parameter that can be adjusted within the Medplum Project to
+   * customize its behavior, only visible to project administrators.
+   */
+  secret?: ProjectSetting[];
+
+  /**
+   * Option or parameter that can be adjusted within the Medplum Project to
+   * customize its behavior, only modifiable by system administrators.
+   */
+  systemSetting?: ProjectSetting[];
+
+  /**
+   * Option or parameter that can be adjusted within the Medplum Project to
+   * customize its behavior, only visible to system administrators.
+   */
+  systemSecret?: ProjectSetting[];
 
   /**
    * Web application or web site that is associated with the project.
@@ -122,10 +188,10 @@ export interface ProjectLink {
 }
 
 /**
- * Secure environment variable that can be used to store secrets for
- * bots.
+ * Option or parameter that can be adjusted within the Medplum Project to
+ * customize its behavior.
  */
-export interface ProjectSecret {
+export interface ProjectSetting {
 
   /**
    * The secret name.
@@ -200,3 +266,8 @@ export interface ProjectSite {
    */
   recaptchaSecretKey?: string;
 }
+
+/**
+ * @deprecated Use ProjectSetting instead
+ */
+export type ProjectSecret = ProjectSetting;

package/dist/ProjectMembership.d.ts

@@ -6,12 +6,15 @@
 import { AccessPolicy } from './AccessPolicy';
 import { Bot } from './Bot';
 import { ClientApplication } from './ClientApplication';
+import { Extension } from './Extension';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
 import { Patient } from './Patient';
 import { Practitioner } from './Practitioner';
 import { Project } from './Project';
 import { Reference } from './Reference';
 import { RelatedPerson } from './RelatedPerson';
+import { Resource } from './Resource';
 import { User } from './User';
 import { UserConfiguration } from './UserConfiguration';
 
@@ -52,6 +55,51 @@ export interface ProjectMembership {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * Project where the memberships are available.
    */

package/dist/SmartAppLaunch.d.ts

@@ -4,9 +4,12 @@
  */
 
 import { Encounter } from './Encounter';
+import { Extension } from './Extension';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
 import { Patient } from './Patient';
 import { Reference } from './Reference';
+import { Resource } from './Resource';
 
 /**
  * This resource contains context details for a SMART App Launch.
@@ -44,6 +47,51 @@ export interface SmartAppLaunch {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * Optional patient indicating that the app was launched in the patient
    * context.

package/dist/User.d.ts

@@ -3,10 +3,13 @@
  * Do not edit manually.
  */
 
+import { Extension } from './Extension';
 import { Identifier } from './Identifier';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
 import { Project } from './Project';
 import { Reference } from './Reference';
+import { Resource } from './Resource';
 
 /**
  * Representation of a human user of the system.
@@ -44,6 +47,51 @@ export interface User {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * An identifier for this user.
    */
@@ -62,7 +110,7 @@ export interface User {
   lastName: string;
 
   /**
-   * DEPRECATED Replaced by ProjectMembership.externalId.
+   * @deprecated Replaced by ProjectMembership.externalId.
    */
   externalId?: string;
 
@@ -78,7 +126,7 @@ export interface User {
   emailVerified?: boolean;
 
   /**
-   * DEPRECATED
+   * @deprecated
    */
   admin?: boolean;
 

package/dist/UserConfiguration.d.ts

@@ -3,7 +3,10 @@
  * Do not edit manually.
  */
 
+import { Extension } from './Extension';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
+import { Resource } from './Resource';
 
 /**
  * User specific configuration for the Medplum application.
@@ -41,6 +44,51 @@ export interface UserConfiguration {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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 name associated with the UserConfiguration.
    */

package/dist/UserSecurityRequest.d.ts

@@ -3,8 +3,11 @@
  * Do not edit manually.
  */
 
+import { Extension } from './Extension';
 import { Meta } from './Meta';
+import { Narrative } from './Narrative';
 import { Reference } from './Reference';
+import { Resource } from './Resource';
 import { User } from './User';
 
 /**
@@ -44,6 +47,51 @@ export interface UserSecurityRequest {
    */
   language?: string;
 
+  /**
+   * A human-readable narrative that contains a summary of the resource and
+   * can be used to represent the content of the resource to a human. The
+   * narrative need not encode all the structured data, but is required to
+   * contain sufficient detail to make it "clinically safe" for a human to
+   * just read the narrative. Resource definitions may define what content
+   * should be represented in the narrative to ensure clinical safety.
+   */
+  text?: Narrative;
+
+  /**
+   * These resources do not have an independent existence apart from the
+   * resource that contains them - they cannot be identified independently,
+   * and nor can they have their own independent transaction scope.
+   */
+  contained?: Resource[];
+
+  /**
+   * May be used to represent additional information that is not part of
+   * the basic definition of the resource. 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 resource and that modifies the
+   * understanding of the element that contains it 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 is allowed to
+   * 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[];
+
   /**
    * The type of user security request.
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medplum/fhirtypes",
-  "version": "3.1.3",
+  "version": "3.1.5",
   "description": "Medplum FHIR Type Definitions",
   "keywords": [
     "medplum",