---
title: "Conditional Update"
method: PUT
path: "/fhir/R4/{resourceType}"
---

# Conditional Update

`PUT /fhir/R4/{resourceType}`

## Request

- Base URL: `https://api.medplum.com`
- URL: `https://api.medplum.com/fhir/R4/{resourceType}`
- Auth: one of:
  - HTTP basic
  - HTTP bearer
  - OpenID Connect (`https://api.medplum.com/.well-known/openid-configuration`)
  - OAuth 2
    - Authorization code: `https://api.medplum.com/oauth2/authorize`
    - Client credentials
    - Token URL: `https://api.medplum.com/oauth2/token`

Update the resource that matches the search criteria, or create it if there is no match. Also known as upsert.

## Path parameters

- `resourceType` 'Account' | 'ActivityDefinition' | 'AdverseEvent' | 'AllergyIntolerance' | 'Appointment' | 'AppointmentResponse' | 'AuditEvent' | 'Basic' | 'Binary' | 'BiologicallyDerivedProduct' | 'BodyStructure' | 'Bundle' | 'CapabilityStatement' | 'CarePlan' | 'CareTeam' | 'CatalogEntry' | 'ChargeItem' | 'ChargeItemDefinition' | 'Claim' | 'ClaimResponse' | 'ClinicalImpression' | 'CodeSystem' | 'Communication' | 'CommunicationRequest' | 'CompartmentDefinition' | 'Composition' | 'ConceptMap' | 'Condition' | 'Consent' | 'Contract' | 'Coverage' | 'CoverageEligibilityRequest' | 'CoverageEligibilityResponse' | 'DetectedIssue' | 'Device' | 'DeviceDefinition' | 'DeviceMetric' | 'DeviceRequest' | 'DeviceUseStatement' | 'DiagnosticReport' | 'DocumentManifest' | 'DocumentReference' | 'EffectEvidenceSynthesis' | 'Encounter' | 'Endpoint' | 'EnrollmentRequest' | 'EnrollmentResponse' | 'EpisodeOfCare' | 'EventDefinition' | 'Evidence' | 'EvidenceVariable' | 'ExampleScenario' | 'ExplanationOfBenefit' | 'FamilyMemberHistory' | 'Flag' | 'Goal' | 'GraphDefinition' | 'Group' | 'GuidanceResponse' | 'HealthcareService' | 'ImagingStudy' | 'Immunization' | 'ImmunizationEvaluation' | 'ImmunizationRecommendation' | 'ImplementationGuide' | 'InsurancePlan' | 'Invoice' | 'Library' | 'Linkage' | 'List' | 'Location' | 'Measure' | 'MeasureReport' | 'Media' | 'Medication' | 'MedicationAdministration' | 'MedicationDispense' | 'MedicationKnowledge' | 'MedicationRequest' | 'MedicationStatement' | 'MedicinalProduct' | 'MedicinalProductAuthorization' | 'MedicinalProductContraindication' | 'MedicinalProductIndication' | 'MedicinalProductIngredient' | 'MedicinalProductInteraction' | 'MedicinalProductManufactured' | 'MedicinalProductPackaged' | 'MedicinalProductPharmaceutical' | 'MedicinalProductUndesirableEffect' | 'MessageDefinition' | 'MessageHeader' | 'MolecularSequence' | 'NamingSystem' | 'NutritionOrder' | 'Observation' | 'ObservationDefinition' | 'OperationDefinition' | 'OperationOutcome' | 'Organization' | 'OrganizationAffiliation' | 'Parameters' | 'Patient' | 'PaymentNotice' | 'PaymentReconciliation' | 'Person' | 'PlanDefinition' | 'Practitioner' | 'PractitionerRole' | 'Procedure' | 'Provenance' | 'Questionnaire' | 'QuestionnaireResponse' | 'RelatedPerson' | 'RequestGroup' | 'ResearchDefinition' | 'ResearchElementDefinition' | 'ResearchStudy' | 'ResearchSubject' | 'RiskAssessment' | 'RiskEvidenceSynthesis' | 'Schedule' | 'SearchParameter' | 'ServiceRequest' | 'Slot' | 'Specimen' | 'SpecimenDefinition' | 'StructureDefinition' | 'StructureMap' | 'Subscription' | 'Substance' | 'SubstanceNucleicAcid' | 'SubstancePolymer' | 'SubstanceProtein' | 'SubstanceReferenceInformation' | 'SubstanceSourceMaterial' | 'SubstanceSpecification' | 'SupplyDelivery' | 'SupplyRequest' | 'Task' | 'TerminologyCapabilities' | 'TestReport' | 'TestScript' | 'ValueSet' | 'VerificationResult' | 'VisionPrescription' | 'Project' | 'ProjectMembership' | 'ClientApplication' | 'User' | 'Login' | 'JsonWebKey' | 'Bot' | 'AccessPolicy' | 'UserConfiguration' | 'BulkDataExport' | 'SmartAppLaunch' | 'DomainConfiguration' | 'AsyncJob' | 'Agent' | 'UserSecurityRequest' | 'Package' | 'PackageRelease' | 'PackageInstallation' | 'SmartHealthLink' | 'DicomStudy' | 'DicomSeries' | 'DicomInstance' | 'Enterprise' | 'Cron', required

## Query parameters

- `criteria` object

## Headers

- `If-Match` string

## Request body

- union
  - Account: A financial tool for tracking value accrued for a particular purpose. In the healthcare field, used to track charges for a patient, cost centers, etc.
    - `resourceType` string, required: This is a Account resource
    - `id` string: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive.
    - `meta` Meta: The metadata about a resource. This is content in the resource that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.
      - `id` string: A sequence of Unicode characters
      - `extension` Extension[]: 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.
        - `id` string: A sequence of Unicode characters
        - `extension` Extension[]: 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.
        - `url` string: String of characters used to identify a name or a resource
        - `valueBase64Binary` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueBoolean` boolean: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueCanonical` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueCode` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueDate` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueDateTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueDecimal` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueId` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueInstant` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueInteger` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueMarkdown` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueOid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valuePositiveInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueString` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueUnsignedInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueUri` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueUrl` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueUuid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueAddress` Address: An address expressed using postal conventions (as opposed to GPS or other location definition formats). This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery. There are a variety of postal address formats defined around the world.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `use` 'home' | 'work' | 'temp' | 'old' | 'billing': The purpose of this address.
          - `type` 'postal' | 'physical' | 'both': Distinguishes between physical addresses (those you can visit) and mailing addresses (e.g. PO Boxes and care-of addresses). Most addresses are both.
          - `text` string: A sequence of Unicode characters
          - `line` String[]: This component contains the house number, apartment number, street name, street direction, P.O. Box number, delivery hints, and similar address information.
          - `city` string: A sequence of Unicode characters
          - `district` string: A sequence of Unicode characters
          - `state` string: A sequence of Unicode characters
          - `postalCode` string: A sequence of Unicode characters
          - `country` string: A sequence of Unicode characters
          - `period` Period: A time period defined by a start and end date and optionally time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
        - `valueAge` Age: A duration of time during which an organism (or a process) has existed.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `value` number: A rational number with implicit precision
          - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
          - `unit` string: A sequence of Unicode characters
          - `system` string: String of characters used to identify a name or a resource
          - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueAnnotation` Annotation: A text note which also contains information about who made the statement and when.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `authorReference` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `authorString` string: The individual responsible for making the annotation.
          - `time` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `text` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
        - `valueAttachment` Attachment: For referring to data content defined in other formats.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `contentType` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `language` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `data` string: A stream of bytes
          - `url` string: A URI that is a literal reference
          - `size` number: An integer with a value that is not negative (e.g. >= 0)
          - `hash` string: A stream of bytes
          - `title` string: A sequence of Unicode characters
          - `creation` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
        - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `coding` Coding[]: A reference to a code defined by a terminology system.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `system` string: String of characters used to identify a name or a resource
            - `version` string: A sequence of Unicode characters
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `display` string: A sequence of Unicode characters
            - `userSelected` boolean: Value of "true" or "false"
          - `text` string: A sequence of Unicode characters
        - `valueCoding` Coding: A reference to a code defined by a terminology system.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `system` string: String of characters used to identify a name or a resource
          - `version` string: A sequence of Unicode characters
          - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `display` string: A sequence of Unicode characters
          - `userSelected` boolean: Value of "true" or "false"
        - `valueContactPoint` ContactPoint: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `system` 'phone' | 'fax' | 'email' | 'pager' | 'url' | 'sms' | 'other': Telecommunications form for contact point - what communications system is required to make use of the contact.
          - `value` string: A sequence of Unicode characters
          - `use` 'home' | 'work' | 'temp' | 'old' | 'mobile': Identifies the purpose for the contact point.
          - `rank` number: An integer with a value that is positive (e.g. >0)
          - `period` Period: A time period defined by a start and end date and optionally time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
        - `valueCount` Count: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `value` number: A rational number with implicit precision
          - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
          - `unit` string: A sequence of Unicode characters
          - `system` string: String of characters used to identify a name or a resource
          - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueDistance` Distance: A length - a value with a unit that is a physical distance.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `value` number: A rational number with implicit precision
          - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
          - `unit` string: A sequence of Unicode characters
          - `system` string: String of characters used to identify a name or a resource
          - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueDuration` Duration: A length of time.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `value` number: A rational number with implicit precision
          - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
          - `unit` string: A sequence of Unicode characters
          - `system` string: String of characters used to identify a name or a resource
          - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueHumanName` HumanName: A human's name with the ability to identify parts and usage.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `use` 'usual' | 'official' | 'temp' | 'nickname' | 'anonymous' | 'old' | 'maiden': Identifies the purpose for this name.
          - `text` string: A sequence of Unicode characters
          - `family` string: A sequence of Unicode characters
          - `given` String[]: Given name.
          - `prefix` String[]: Part of the name that is acquired as a title due to academic, legal, employment or nobility status, etc. and that appears at the start of the name.
          - `suffix` String[]: Part of the name that is acquired as a title due to academic, legal, employment or nobility status, etc. and that appears at the end of the name.
          - `period` Period: A time period defined by a start and end date and optionally time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
        - `valueIdentifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `use` 'usual' | 'official' | 'temp' | 'secondary' | 'old': The purpose of this identifier.
          - `type` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `system` string: String of characters used to identify a name or a resource
          - `value` string: A sequence of Unicode characters
          - `period` Period: A time period defined by a start and end date and optionally time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `assigner` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier (recursive)
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
        - `valueMoney` Money: An amount of economic utility in some recognized currency.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `value` number: A rational number with implicit precision
          - `currency` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valuePeriod` Period: A time period defined by a start and end date and optionally time.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
        - `valueQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `value` number: A rational number with implicit precision
          - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
          - `unit` string: A sequence of Unicode characters
          - `system` string: String of characters used to identify a name or a resource
          - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueRange` Range: A set of ordered Quantities defined by a low and high limit.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `low` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `high` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueRatio` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `numerator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `denominator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueReference` Reference: A reference from one resource to another.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `reference` string: A sequence of Unicode characters
          - `type` string: String of characters used to identify a name or a resource
          - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'usual' | 'official' | 'temp' | 'secondary' | 'old': The purpose of this identifier.
            - `type` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `system` string: String of characters used to identify a name or a resource
            - `value` string: A sequence of Unicode characters
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
            - `assigner` Reference (recursive)
          - `display` string: A sequence of Unicode characters
          - `resource` ResourceList (recursive)
        - `valueSampledData` SampledData: A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `origin` Quantity, required: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `period` number: A rational number with implicit precision
          - `factor` number: A rational number with implicit precision
          - `lowerLimit` number: A rational number with implicit precision
          - `upperLimit` number: A rational number with implicit precision
          - `dimensions` number: An integer with a value that is positive (e.g. >0)
          - `data` string: A sequence of Unicode characters
        - `valueSignature` Signature: A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `type` Coding[], required: An indication of the reason that the entity signed this document. This may be explicitly included as part of the signature information and can be used when determining accountability for various actions concerning the document.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `system` string: String of characters used to identify a name or a resource
            - `version` string: A sequence of Unicode characters
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `display` string: A sequence of Unicode characters
            - `userSelected` boolean: Value of "true" or "false"
          - `when` string: An instant in time - known at least to the second
          - `who` Reference, required: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `onBehalfOf` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `targetFormat` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `sigFormat` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `data` string: A stream of bytes
        - `valueTiming` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `modifierExtension` 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).
          - `event` DateTime[]: Identifies specific times when the event occurs.
          - `repeat` TimingRepeat: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `boundsDuration` Duration: A length of time.
              - …
            - `boundsRange` Range: A set of ordered Quantities defined by a low and high limit.
              - …
            - `boundsPeriod` Period: A time period defined by a start and end date and optionally time.
              - …
            - `count` number: An integer with a value that is positive (e.g. >0)
            - `countMax` number: An integer with a value that is positive (e.g. >0)
            - `duration` number: A rational number with implicit precision
            - `durationMax` number: A rational number with implicit precision
            - `durationUnit` 's' | 'min' | 'h' | 'd' | 'wk' | 'mo' | 'a': The units of time for the duration, in UCUM units.
            - `frequency` number: An integer with a value that is positive (e.g. >0)
            - `frequencyMax` number: An integer with a value that is positive (e.g. >0)
            - `period` number: A rational number with implicit precision
            - `periodMax` number: A rational number with implicit precision
            - `periodUnit` 's' | 'min' | 'h' | 'd' | 'wk' | 'mo' | 'a': The units of time for the period in UCUM units.
            - `dayOfWeek` Code[]: If one or more days of week is provided, then the action happens only on the specified day(s).
            - `timeOfDay` Time[]: Specified time of day for action to take place.
            - `when` string[]: An approximate time period during the day, potentially linked to an event of daily living that indicates when the action should occur.
            - `offset` number: An integer with a value that is not negative (e.g. >= 0)
          - `code` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
        - `valueContactDetail` ContactDetail: Specifies contact information for a person or organization.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `name` string: A sequence of Unicode characters
          - `telecom` ContactPoint[]: The contact details for the individual (if a name was provided) or the organization.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `system` 'phone' | 'fax' | 'email' | 'pager' | 'url' | 'sms' | 'other': Telecommunications form for contact point - what communications system is required to make use of the contact.
            - `value` string: A sequence of Unicode characters
            - `use` 'home' | 'work' | 'temp' | 'old' | 'mobile': Identifies the purpose for the contact point.
            - `rank` number: An integer with a value that is positive (e.g. >0)
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
        - `valueContributor` Contributor: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `type` 'author' | 'editor' | 'reviewer' | 'endorser': The type of contributor.
          - `name` string: A sequence of Unicode characters
          - `contact` ContactDetail[]: Contact details to assist a user in finding and communicating with the contributor.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `name` string: A sequence of Unicode characters
            - `telecom` ContactPoint[]: The contact details for the individual (if a name was provided) or the organization.
              - …
        - `valueDataRequirement` DataRequirement: Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `profile` Canonical[]: The profile of the required data, specified as the uri of the profile definition.
          - `subjectCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `subjectReference` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `mustSupport` String[]: Indicates that specific elements of the type are referenced by the knowledge module and must be supported by the consumer in order to obtain an effective evaluation. This does not mean that a value is required for this element, only that the consuming system must understand the element and be able to provide values for it if they are available. The value of mustSupport SHALL be a FHIRPath resolveable on the type of the DataRequirement. The path SHALL consist only of identifiers, constant indexers, and .resolve() (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details).
          - `codeFilter` DataRequirementCodeFilter[]: Code filters specify additional constraints on the data, specifying the value set of interest for a particular element of the data. Each code filter defines an additional constraint on the data, i.e. code filters are AND'ed, not OR'ed.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `path` string: A sequence of Unicode characters
            - `searchParam` string: A sequence of Unicode characters
            - `valueSet` string: A URI that is a reference to a canonical URL on a FHIR resource
            - `code` Coding[]: The codes for the code filter. If values are given, the filter will return only those data items for which the code-valued attribute specified by the path has a value that is one of the specified codes. If codes are specified in addition to a value set, the filter returns items matching a code in the value set or one of the specified codes.
              - …
          - `dateFilter` DataRequirementDateFilter[]: Date filters specify additional constraints on the data in terms of the applicable date range for specific elements. Each date filter specifies an additional constraint on the data, i.e. date filters are AND'ed, not OR'ed.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `path` string: A sequence of Unicode characters
            - `searchParam` string: A sequence of Unicode characters
            - `valueDateTime` string: The value of the filter. If period is specified, the filter will return only those data items that fall within the bounds determined by the Period, inclusive of the period boundaries. If dateTime is specified, the filter will return only those data items that are equal to the specified dateTime. If a Duration is specified, the filter will return only those data items that fall within Duration before now.
            - `valuePeriod` Period: A time period defined by a start and end date and optionally time.
              - …
            - `valueDuration` Duration: A length of time.
              - …
          - `limit` number: An integer with a value that is positive (e.g. >0)
          - `sort` DataRequirementSort[]: Specifies the order of the results to be returned.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `path` string: A sequence of Unicode characters
            - `direction` 'ascending' | 'descending': The direction of the sort, ascending or descending.
        - `valueExpression` Expression: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `description` string: A sequence of Unicode characters
          - `name` string: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive.
          - `language` 'text/cql' | 'text/fhirpath' | 'application/x-fhir-query': The media type of the language for the expression.
          - `expression` string: A sequence of Unicode characters
          - `reference` string: String of characters used to identify a name or a resource
        - `valueParameterDefinition` ParameterDefinition: The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `name` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `use` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `min` number: A whole number
          - `max` string: A sequence of Unicode characters
          - `documentation` string: A sequence of Unicode characters
          - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `profile` string: A URI that is a reference to a canonical URL on a FHIR resource
        - `valueRelatedArtifact` RelatedArtifact: Related artifacts such as additional documentation, justification, or bibliographic references.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `type` 'documentation' | 'justification' | 'citation' | 'predecessor' | 'successor' | 'derived-from' | 'depends-on' | 'composed-of': The type of relationship to the related artifact.
          - `label` string: A sequence of Unicode characters
          - `display` string: A sequence of Unicode characters
          - `citation` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
          - `url` string: A URI that is a literal reference
          - `document` Attachment: For referring to data content defined in other formats.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `contentType` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `language` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `data` string: A stream of bytes
            - `url` string: A URI that is a literal reference
            - `size` number: An integer with a value that is not negative (e.g. >= 0)
            - `hash` string: A stream of bytes
            - `title` string: A sequence of Unicode characters
            - `creation` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `resource` string: A URI that is a reference to a canonical URL on a FHIR resource
        - `valueTriggerDefinition` TriggerDefinition: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `type` 'named-event' | 'periodic' | 'data-changed' | 'data-added' | 'data-modified' | 'data-removed' | 'data-accessed' | 'data-access-ended': The type of triggering event.
          - `name` string: A sequence of Unicode characters
          - `timingTiming` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `event` DateTime[]: Identifies specific times when the event occurs.
            - `repeat` TimingRepeat: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `code` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
          - `timingReference` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `timingDate` string: The timing of the event (if this is a periodic trigger).
          - `timingDateTime` string: The timing of the event (if this is a periodic trigger).
          - `data` DataRequirement[]: The triggering data of the event (if this is a data trigger). If more than one data is requirement is specified, then all the data requirements must be true.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `profile` Canonical[]: The profile of the required data, specified as the uri of the profile definition.
            - `subjectCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `subjectReference` Reference: A reference from one resource to another.
              - …
            - `mustSupport` String[]: Indicates that specific elements of the type are referenced by the knowledge module and must be supported by the consumer in order to obtain an effective evaluation. This does not mean that a value is required for this element, only that the consuming system must understand the element and be able to provide values for it if they are available. The value of mustSupport SHALL be a FHIRPath resolveable on the type of the DataRequirement. The path SHALL consist only of identifiers, constant indexers, and .resolve() (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details).
            - `codeFilter` DataRequirementCodeFilter[]: Code filters specify additional constraints on the data, specifying the value set of interest for a particular element of the data. Each code filter defines an additional constraint on the data, i.e. code filters are AND'ed, not OR'ed.
              - …
            - `dateFilter` DataRequirementDateFilter[]: Date filters specify additional constraints on the data in terms of the applicable date range for specific elements. Each date filter specifies an additional constraint on the data, i.e. date filters are AND'ed, not OR'ed.
              - …
            - `limit` number: An integer with a value that is positive (e.g. >0)
            - `sort` DataRequirementSort[]: Specifies the order of the results to be returned.
              - …
          - `condition` Expression: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `description` string: A sequence of Unicode characters
            - `name` string: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive.
            - `language` 'text/cql' | 'text/fhirpath' | 'application/x-fhir-query': The media type of the language for the expression.
            - `expression` string: A sequence of Unicode characters
            - `reference` string: String of characters used to identify a name or a resource
        - `valueUsageContext` UsageContext: Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `code` Coding, required: A reference to a code defined by a terminology system.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `system` string: String of characters used to identify a name or a resource
            - `version` string: A sequence of Unicode characters
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `display` string: A sequence of Unicode characters
            - `userSelected` boolean: Value of "true" or "false"
          - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `valueQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueRange` Range: A set of ordered Quantities defined by a low and high limit.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `low` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `high` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueReference` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
        - `valueDosage` Dosage: Indicates how the medication is/was taken or should be taken by the patient.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `modifierExtension` 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).
          - `sequence` number: A whole number
          - `text` string: A sequence of Unicode characters
          - `additionalInstruction` CodeableConcept[]: Supplemental instructions to the patient on how to take the medication (e.g. "with meals" or"take half to one hour before food") or warnings for the patient about the medication (e.g. "may cause drowsiness" or "avoid exposure of skin to direct sunlight or sunlamps").
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `patientInstruction` string: A sequence of Unicode characters
          - `timing` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `event` DateTime[]: Identifies specific times when the event occurs.
            - `repeat` TimingRepeat: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `code` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
          - `asNeededBoolean` boolean: Indicates whether the Medication is only taken when needed within a specific dosing schedule (Boolean option), or it indicates the precondition for taking the Medication (CodeableConcept).
          - `asNeededCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `site` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `route` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `method` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `doseAndRate` DosageDoseAndRate[]: The amount of medication administered.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `type` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `doseRange` Range: A set of ordered Quantities defined by a low and high limit.
              - …
            - `doseQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `rateRatio` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
              - …
            - `rateRange` Range: A set of ordered Quantities defined by a low and high limit.
              - …
            - `rateQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `maxDosePerPeriod` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `numerator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `denominator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `maxDosePerAdministration` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `maxDosePerLifetime` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueMeta` Meta (recursive)
      - `versionId` string: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive.
      - `lastUpdated` string: An instant in time - known at least to the second
      - `source` string: String of characters used to identify a name or a resource
      - `profile` Canonical[]: A list of profiles (references to [[[StructureDefinition]]] resources) that this resource claims to conform to. The URL is a reference to [[[StructureDefinition.url]]].
      - `security` Coding[]: Security labels applied to this resource. These tags connect specific resources to the overall security policy and infrastructure.
        - `id` string: A sequence of Unicode characters
        - `extension` Extension[]: 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.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `url` string: String of characters used to identify a name or a resource
          - `valueBase64Binary` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueBoolean` boolean: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueCanonical` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueCode` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDate` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDateTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDecimal` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueId` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueInstant` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueInteger` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueMarkdown` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueOid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valuePositiveInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueString` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUnsignedInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUri` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUrl` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUuid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueAddress` Address: An address expressed using postal conventions (as opposed to GPS or other location definition formats). This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery. There are a variety of postal address formats defined around the world.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'home' | 'work' | 'temp' | 'old' | 'billing': The purpose of this address.
            - `type` 'postal' | 'physical' | 'both': Distinguishes between physical addresses (those you can visit) and mailing addresses (e.g. PO Boxes and care-of addresses). Most addresses are both.
            - `text` string: A sequence of Unicode characters
            - `line` String[]: This component contains the house number, apartment number, street name, street direction, P.O. Box number, delivery hints, and similar address information.
            - `city` string: A sequence of Unicode characters
            - `district` string: A sequence of Unicode characters
            - `state` string: A sequence of Unicode characters
            - `postalCode` string: A sequence of Unicode characters
            - `country` string: A sequence of Unicode characters
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueAge` Age: A duration of time during which an organism (or a process) has existed.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueAnnotation` Annotation: A text note which also contains information about who made the statement and when.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `authorReference` Reference: A reference from one resource to another.
              - …
            - `authorString` string: The individual responsible for making the annotation.
            - `time` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `text` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
          - `valueAttachment` Attachment: For referring to data content defined in other formats.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `contentType` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `language` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `data` string: A stream of bytes
            - `url` string: A URI that is a literal reference
            - `size` number: An integer with a value that is not negative (e.g. >= 0)
            - `hash` string: A stream of bytes
            - `title` string: A sequence of Unicode characters
            - `creation` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
            - `text` string: A sequence of Unicode characters
          - `valueCoding` Coding (recursive)
          - `valueContactPoint` ContactPoint: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `system` 'phone' | 'fax' | 'email' | 'pager' | 'url' | 'sms' | 'other': Telecommunications form for contact point - what communications system is required to make use of the contact.
            - `value` string: A sequence of Unicode characters
            - `use` 'home' | 'work' | 'temp' | 'old' | 'mobile': Identifies the purpose for the contact point.
            - `rank` number: An integer with a value that is positive (e.g. >0)
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueCount` Count: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueDistance` Distance: A length - a value with a unit that is a physical distance.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueDuration` Duration: A length of time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueHumanName` HumanName: A human's name with the ability to identify parts and usage.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'usual' | 'official' | 'temp' | 'nickname' | 'anonymous' | 'old' | 'maiden': Identifies the purpose for this name.
            - `text` string: A sequence of Unicode characters
            - `family` string: A sequence of Unicode characters
            - `given` String[]: Given name.
            - `prefix` String[]: Part of the name that is acquired as a title due to academic, legal, employment or nobility status, etc. and that appears at the start of the name.
            - `suffix` String[]: Part of the name that is acquired as a title due to academic, legal, employment or nobility status, etc. and that appears at the end of the name.
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueIdentifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'usual' | 'official' | 'temp' | 'secondary' | 'old': The purpose of this identifier.
            - `type` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `system` string: String of characters used to identify a name or a resource
            - `value` string: A sequence of Unicode characters
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
            - `assigner` Reference: A reference from one resource to another.
              - …
          - `valueMoney` Money: An amount of economic utility in some recognized currency.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `currency` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valuePeriod` Period: A time period defined by a start and end date and optionally time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `valueQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueRange` Range: A set of ordered Quantities defined by a low and high limit.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `low` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `high` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueRatio` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `numerator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `denominator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueReference` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `valueSampledData` SampledData: A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `origin` Quantity, required: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `period` number: A rational number with implicit precision
            - `factor` number: A rational number with implicit precision
            - `lowerLimit` number: A rational number with implicit precision
            - `upperLimit` number: A rational number with implicit precision
            - `dimensions` number: An integer with a value that is positive (e.g. >0)
            - `data` string: A sequence of Unicode characters
          - `valueSignature` Signature: A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` Coding[], required: An indication of the reason that the entity signed this document. This may be explicitly included as part of the signature information and can be used when determining accountability for various actions concerning the document.
            - `when` string: An instant in time - known at least to the second
            - `who` Reference, required: A reference from one resource to another.
              - …
            - `onBehalfOf` Reference: A reference from one resource to another.
              - …
            - `targetFormat` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `sigFormat` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `data` string: A stream of bytes
          - `valueTiming` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `event` DateTime[]: Identifies specific times when the event occurs.
            - `repeat` TimingRepeat: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `code` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
          - `valueContactDetail` ContactDetail: Specifies contact information for a person or organization.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `name` string: A sequence of Unicode characters
            - `telecom` ContactPoint[]: The contact details for the individual (if a name was provided) or the organization.
              - …
          - `valueContributor` Contributor: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` 'author' | 'editor' | 'reviewer' | 'endorser': The type of contributor.
            - `name` string: A sequence of Unicode characters
            - `contact` ContactDetail[]: Contact details to assist a user in finding and communicating with the contributor.
              - …
          - `valueDataRequirement` DataRequirement: Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `profile` Canonical[]: The profile of the required data, specified as the uri of the profile definition.
            - `subjectCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `subjectReference` Reference: A reference from one resource to another.
              - …
            - `mustSupport` String[]: Indicates that specific elements of the type are referenced by the knowledge module and must be supported by the consumer in order to obtain an effective evaluation. This does not mean that a value is required for this element, only that the consuming system must understand the element and be able to provide values for it if they are available. The value of mustSupport SHALL be a FHIRPath resolveable on the type of the DataRequirement. The path SHALL consist only of identifiers, constant indexers, and .resolve() (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details).
            - `codeFilter` DataRequirementCodeFilter[]: Code filters specify additional constraints on the data, specifying the value set of interest for a particular element of the data. Each code filter defines an additional constraint on the data, i.e. code filters are AND'ed, not OR'ed.
              - …
            - `dateFilter` DataRequirementDateFilter[]: Date filters specify additional constraints on the data in terms of the applicable date range for specific elements. Each date filter specifies an additional constraint on the data, i.e. date filters are AND'ed, not OR'ed.
              - …
            - `limit` number: An integer with a value that is positive (e.g. >0)
            - `sort` DataRequirementSort[]: Specifies the order of the results to be returned.
              - …
          - `valueExpression` Expression: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `description` string: A sequence of Unicode characters
            - `name` string: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive.
            - `language` 'text/cql' | 'text/fhirpath' | 'application/x-fhir-query': The media type of the language for the expression.
            - `expression` string: A sequence of Unicode characters
            - `reference` string: String of characters used to identify a name or a resource
          - `valueParameterDefinition` ParameterDefinition: The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `name` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `use` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `min` number: A whole number
            - `max` string: A sequence of Unicode characters
            - `documentation` string: A sequence of Unicode characters
            - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `profile` string: A URI that is a reference to a canonical URL on a FHIR resource
          - `valueRelatedArtifact` RelatedArtifact: Related artifacts such as additional documentation, justification, or bibliographic references.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` 'documentation' | 'justification' | 'citation' | 'predecessor' | 'successor' | 'derived-from' | 'depends-on' | 'composed-of': The type of relationship to the related artifact.
            - `label` string: A sequence of Unicode characters
            - `display` string: A sequence of Unicode characters
            - `citation` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
            - `url` string: A URI that is a literal reference
            - `document` Attachment: For referring to data content defined in other formats.
              - …
            - `resource` string: A URI that is a reference to a canonical URL on a FHIR resource
          - `valueTriggerDefinition` TriggerDefinition: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` 'named-event' | 'periodic' | 'data-changed' | 'data-added' | 'data-modified' | 'data-removed' | 'data-accessed' | 'data-access-ended': The type of triggering event.
            - `name` string: A sequence of Unicode characters
            - `timingTiming` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `timingReference` Reference: A reference from one resource to another.
              - …
            - `timingDate` string: The timing of the event (if this is a periodic trigger).
            - `timingDateTime` string: The timing of the event (if this is a periodic trigger).
            - `data` DataRequirement[]: The triggering data of the event (if this is a data trigger). If more than one data is requirement is specified, then all the data requirements must be true.
              - …
            - `condition` Expression: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
              - …
          - `valueUsageContext` UsageContext: Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `code` Coding, required (recursive)
            - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `valueQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `valueRange` Range: A set of ordered Quantities defined by a low and high limit.
              - …
            - `valueReference` Reference: A reference from one resource to another.
              - …
          - `valueDosage` Dosage: Indicates how the medication is/was taken or should be taken by the patient.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `sequence` number: A whole number
            - `text` string: A sequence of Unicode characters
            - `additionalInstruction` CodeableConcept[]: Supplemental instructions to the patient on how to take the medication (e.g. "with meals" or"take half to one hour before food") or warnings for the patient about the medication (e.g. "may cause drowsiness" or "avoid exposure of skin to direct sunlight or sunlamps").
              - …
            - `patientInstruction` string: A sequence of Unicode characters
            - `timing` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `asNeededBoolean` boolean: Indicates whether the Medication is only taken when needed within a specific dosing schedule (Boolean option), or it indicates the precondition for taking the Medication (CodeableConcept).
            - `asNeededCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `site` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `route` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `method` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `doseAndRate` DosageDoseAndRate[]: The amount of medication administered.
              - …
            - `maxDosePerPeriod` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
              - …
            - `maxDosePerAdministration` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `maxDosePerLifetime` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueMeta` Meta (recursive)
        - `system` string: String of characters used to identify a name or a resource
        - `version` string: A sequence of Unicode characters
        - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `display` string: A sequence of Unicode characters
        - `userSelected` boolean: Value of "true" or "false"
      - `tag` Coding[]: Tags applied to this resource. Tags are intended to be used to identify and relate resources to process and workflow, and applications are not required to consider the tags when interpreting the meaning of a resource.
        - `id` string: A sequence of Unicode characters
        - `extension` Extension[]: 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.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `url` string: String of characters used to identify a name or a resource
          - `valueBase64Binary` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueBoolean` boolean: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueCanonical` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueCode` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDate` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDateTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDecimal` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueId` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueInstant` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueInteger` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueMarkdown` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueOid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valuePositiveInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueString` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUnsignedInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUri` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUrl` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUuid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueAddress` Address: An address expressed using postal conventions (as opposed to GPS or other location definition formats). This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery. There are a variety of postal address formats defined around the world.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'home' | 'work' | 'temp' | 'old' | 'billing': The purpose of this address.
            - `type` 'postal' | 'physical' | 'both': Distinguishes between physical addresses (those you can visit) and mailing addresses (e.g. PO Boxes and care-of addresses). Most addresses are both.
            - `text` string: A sequence of Unicode characters
            - `line` String[]: This component contains the house number, apartment number, street name, street direction, P.O. Box number, delivery hints, and similar address information.
            - `city` string: A sequence of Unicode characters
            - `district` string: A sequence of Unicode characters
            - `state` string: A sequence of Unicode characters
            - `postalCode` string: A sequence of Unicode characters
            - `country` string: A sequence of Unicode characters
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueAge` Age: A duration of time during which an organism (or a process) has existed.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueAnnotation` Annotation: A text note which also contains information about who made the statement and when.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `authorReference` Reference: A reference from one resource to another.
              - …
            - `authorString` string: The individual responsible for making the annotation.
            - `time` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `text` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
          - `valueAttachment` Attachment: For referring to data content defined in other formats.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `contentType` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `language` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `data` string: A stream of bytes
            - `url` string: A URI that is a literal reference
            - `size` number: An integer with a value that is not negative (e.g. >= 0)
            - `hash` string: A stream of bytes
            - `title` string: A sequence of Unicode characters
            - `creation` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
            - `text` string: A sequence of Unicode characters
          - `valueCoding` Coding (recursive)
          - `valueContactPoint` ContactPoint: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `system` 'phone' | 'fax' | 'email' | 'pager' | 'url' | 'sms' | 'other': Telecommunications form for contact point - what communications system is required to make use of the contact.
            - `value` string: A sequence of Unicode characters
            - `use` 'home' | 'work' | 'temp' | 'old' | 'mobile': Identifies the purpose for the contact point.
            - `rank` number: An integer with a value that is positive (e.g. >0)
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueCount` Count: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueDistance` Distance: A length - a value with a unit that is a physical distance.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueDuration` Duration: A length of time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueHumanName` HumanName: A human's name with the ability to identify parts and usage.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'usual' | 'official' | 'temp' | 'nickname' | 'anonymous' | 'old' | 'maiden': Identifies the purpose for this name.
            - `text` string: A sequence of Unicode characters
            - `family` string: A sequence of Unicode characters
            - `given` String[]: Given name.
            - `prefix` String[]: Part of the name that is acquired as a title due to academic, legal, employment or nobility status, etc. and that appears at the start of the name.
            - `suffix` String[]: Part of the name that is acquired as a title due to academic, legal, employment or nobility status, etc. and that appears at the end of the name.
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueIdentifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'usual' | 'official' | 'temp' | 'secondary' | 'old': The purpose of this identifier.
            - `type` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `system` string: String of characters used to identify a name or a resource
            - `value` string: A sequence of Unicode characters
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
            - `assigner` Reference: A reference from one resource to another.
              - …
          - `valueMoney` Money: An amount of economic utility in some recognized currency.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `currency` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valuePeriod` Period: A time period defined by a start and end date and optionally time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `valueQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueRange` Range: A set of ordered Quantities defined by a low and high limit.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `low` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `high` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueRatio` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `numerator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `denominator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueReference` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `valueSampledData` SampledData: A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `origin` Quantity, required: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `period` number: A rational number with implicit precision
            - `factor` number: A rational number with implicit precision
            - `lowerLimit` number: A rational number with implicit precision
            - `upperLimit` number: A rational number with implicit precision
            - `dimensions` number: An integer with a value that is positive (e.g. >0)
            - `data` string: A sequence of Unicode characters
          - `valueSignature` Signature: A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` Coding[], required: An indication of the reason that the entity signed this document. This may be explicitly included as part of the signature information and can be used when determining accountability for various actions concerning the document.
            - `when` string: An instant in time - known at least to the second
            - `who` Reference, required: A reference from one resource to another.
              - …
            - `onBehalfOf` Reference: A reference from one resource to another.
              - …
            - `targetFormat` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `sigFormat` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `data` string: A stream of bytes
          - `valueTiming` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `event` DateTime[]: Identifies specific times when the event occurs.
            - `repeat` TimingRepeat: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `code` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
          - `valueContactDetail` ContactDetail: Specifies contact information for a person or organization.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `name` string: A sequence of Unicode characters
            - `telecom` ContactPoint[]: The contact details for the individual (if a name was provided) or the organization.
              - …
          - `valueContributor` Contributor: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` 'author' | 'editor' | 'reviewer' | 'endorser': The type of contributor.
            - `name` string: A sequence of Unicode characters
            - `contact` ContactDetail[]: Contact details to assist a user in finding and communicating with the contributor.
              - …
          - `valueDataRequirement` DataRequirement: Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `profile` Canonical[]: The profile of the required data, specified as the uri of the profile definition.
            - `subjectCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `subjectReference` Reference: A reference from one resource to another.
              - …
            - `mustSupport` String[]: Indicates that specific elements of the type are referenced by the knowledge module and must be supported by the consumer in order to obtain an effective evaluation. This does not mean that a value is required for this element, only that the consuming system must understand the element and be able to provide values for it if they are available. The value of mustSupport SHALL be a FHIRPath resolveable on the type of the DataRequirement. The path SHALL consist only of identifiers, constant indexers, and .resolve() (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details).
            - `codeFilter` DataRequirementCodeFilter[]: Code filters specify additional constraints on the data, specifying the value set of interest for a particular element of the data. Each code filter defines an additional constraint on the data, i.e. code filters are AND'ed, not OR'ed.
              - …
            - `dateFilter` DataRequirementDateFilter[]: Date filters specify additional constraints on the data in terms of the applicable date range for specific elements. Each date filter specifies an additional constraint on the data, i.e. date filters are AND'ed, not OR'ed.
              - …
            - `limit` number: An integer with a value that is positive (e.g. >0)
            - `sort` DataRequirementSort[]: Specifies the order of the results to be returned.
              - …
          - `valueExpression` Expression: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `description` string: A sequence of Unicode characters
            - `name` string: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive.
            - `language` 'text/cql' | 'text/fhirpath' | 'application/x-fhir-query': The media type of the language for the expression.
            - `expression` string: A sequence of Unicode characters
            - `reference` string: String of characters used to identify a name or a resource
          - `valueParameterDefinition` ParameterDefinition: The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `name` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `use` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `min` number: A whole number
            - `max` string: A sequence of Unicode characters
            - `documentation` string: A sequence of Unicode characters
            - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `profile` string: A URI that is a reference to a canonical URL on a FHIR resource
          - `valueRelatedArtifact` RelatedArtifact: Related artifacts such as additional documentation, justification, or bibliographic references.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` 'documentation' | 'justification' | 'citation' | 'predecessor' | 'successor' | 'derived-from' | 'depends-on' | 'composed-of': The type of relationship to the related artifact.
            - `label` string: A sequence of Unicode characters
            - `display` string: A sequence of Unicode characters
            - `citation` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
            - `url` string: A URI that is a literal reference
            - `document` Attachment: For referring to data content defined in other formats.
              - …
            - `resource` string: A URI that is a reference to a canonical URL on a FHIR resource
          - `valueTriggerDefinition` TriggerDefinition: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` 'named-event' | 'periodic' | 'data-changed' | 'data-added' | 'data-modified' | 'data-removed' | 'data-accessed' | 'data-access-ended': The type of triggering event.
            - `name` string: A sequence of Unicode characters
            - `timingTiming` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `timingReference` Reference: A reference from one resource to another.
              - …
            - `timingDate` string: The timing of the event (if this is a periodic trigger).
            - `timingDateTime` string: The timing of the event (if this is a periodic trigger).
            - `data` DataRequirement[]: The triggering data of the event (if this is a data trigger). If more than one data is requirement is specified, then all the data requirements must be true.
              - …
            - `condition` Expression: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
              - …
          - `valueUsageContext` UsageContext: Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `code` Coding, required (recursive)
            - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `valueQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `valueRange` Range: A set of ordered Quantities defined by a low and high limit.
              - …
            - `valueReference` Reference: A reference from one resource to another.
              - …
          - `valueDosage` Dosage: Indicates how the medication is/was taken or should be taken by the patient.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `sequence` number: A whole number
            - `text` string: A sequence of Unicode characters
            - `additionalInstruction` CodeableConcept[]: Supplemental instructions to the patient on how to take the medication (e.g. "with meals" or"take half to one hour before food") or warnings for the patient about the medication (e.g. "may cause drowsiness" or "avoid exposure of skin to direct sunlight or sunlamps").
              - …
            - `patientInstruction` string: A sequence of Unicode characters
            - `timing` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `asNeededBoolean` boolean: Indicates whether the Medication is only taken when needed within a specific dosing schedule (Boolean option), or it indicates the precondition for taking the Medication (CodeableConcept).
            - `asNeededCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `site` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `route` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `method` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `doseAndRate` DosageDoseAndRate[]: The amount of medication administered.
              - …
            - `maxDosePerPeriod` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
              - …
            - `maxDosePerAdministration` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `maxDosePerLifetime` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueMeta` Meta (recursive)
        - `system` string: String of characters used to identify a name or a resource
        - `version` string: A sequence of Unicode characters
        - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `display` string: A sequence of Unicode characters
        - `userSelected` boolean: Value of "true" or "false"
      - `project` string: String of characters used to identify a name or a resource
      - `author` Reference: A reference from one resource to another.
        - `id` string: A sequence of Unicode characters
        - `extension` Extension[]: 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.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `url` string: String of characters used to identify a name or a resource
          - `valueBase64Binary` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueBoolean` boolean: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueCanonical` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueCode` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDate` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDateTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDecimal` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueId` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueInstant` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueInteger` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueMarkdown` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueOid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valuePositiveInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueString` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUnsignedInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUri` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUrl` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUuid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueAddress` Address: An address expressed using postal conventions (as opposed to GPS or other location definition formats). This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery. There are a variety of postal address formats defined around the world.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'home' | 'work' | 'temp' | 'old' | 'billing': The purpose of this address.
            - `type` 'postal' | 'physical' | 'both': Distinguishes between physical addresses (those you can visit) and mailing addresses (e.g. PO Boxes and care-of addresses). Most addresses are both.
            - `text` string: A sequence of Unicode characters
            - `line` String[]: This component contains the house number, apartment number, street name, street direction, P.O. Box number, delivery hints, and similar address information.
            - `city` string: A sequence of Unicode characters
            - `district` string: A sequence of Unicode characters
            - `state` string: A sequence of Unicode characters
            - `postalCode` string: A sequence of Unicode characters
            - `country` string: A sequence of Unicode characters
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueAge` Age: A duration of time during which an organism (or a process) has existed.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueAnnotation` Annotation: A text note which also contains information about who made the statement and when.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `authorReference` Reference (recursive)
            - `authorString` string: The individual responsible for making the annotation.
            - `time` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `text` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
          - `valueAttachment` Attachment: For referring to data content defined in other formats.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `contentType` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `language` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `data` string: A stream of bytes
            - `url` string: A URI that is a literal reference
            - `size` number: An integer with a value that is not negative (e.g. >= 0)
            - `hash` string: A stream of bytes
            - `title` string: A sequence of Unicode characters
            - `creation` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
- … truncated; see the full OpenAPI document linked below

## Response `200`

Matched one resource, which was updated

- union
  - Account: A financial tool for tracking value accrued for a particular purpose. In the healthcare field, used to track charges for a patient, cost centers, etc.
    - `resourceType` string, required: This is a Account resource
    - `id` string: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive.
    - `meta` Meta: The metadata about a resource. This is content in the resource that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.
      - `id` string: A sequence of Unicode characters
      - `extension` Extension[]: 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.
        - `id` string: A sequence of Unicode characters
        - `extension` Extension[]: 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.
        - `url` string: String of characters used to identify a name or a resource
        - `valueBase64Binary` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueBoolean` boolean: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueCanonical` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueCode` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueDate` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueDateTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueDecimal` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueId` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueInstant` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueInteger` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueMarkdown` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueOid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valuePositiveInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueString` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueUnsignedInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueUri` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueUrl` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueUuid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
        - `valueAddress` Address: An address expressed using postal conventions (as opposed to GPS or other location definition formats). This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery. There are a variety of postal address formats defined around the world.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `use` 'home' | 'work' | 'temp' | 'old' | 'billing': The purpose of this address.
          - `type` 'postal' | 'physical' | 'both': Distinguishes between physical addresses (those you can visit) and mailing addresses (e.g. PO Boxes and care-of addresses). Most addresses are both.
          - `text` string: A sequence of Unicode characters
          - `line` String[]: This component contains the house number, apartment number, street name, street direction, P.O. Box number, delivery hints, and similar address information.
          - `city` string: A sequence of Unicode characters
          - `district` string: A sequence of Unicode characters
          - `state` string: A sequence of Unicode characters
          - `postalCode` string: A sequence of Unicode characters
          - `country` string: A sequence of Unicode characters
          - `period` Period: A time period defined by a start and end date and optionally time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
        - `valueAge` Age: A duration of time during which an organism (or a process) has existed.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `value` number: A rational number with implicit precision
          - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
          - `unit` string: A sequence of Unicode characters
          - `system` string: String of characters used to identify a name or a resource
          - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueAnnotation` Annotation: A text note which also contains information about who made the statement and when.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `authorReference` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `authorString` string: The individual responsible for making the annotation.
          - `time` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `text` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
        - `valueAttachment` Attachment: For referring to data content defined in other formats.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `contentType` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `language` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `data` string: A stream of bytes
          - `url` string: A URI that is a literal reference
          - `size` number: An integer with a value that is not negative (e.g. >= 0)
          - `hash` string: A stream of bytes
          - `title` string: A sequence of Unicode characters
          - `creation` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
        - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `coding` Coding[]: A reference to a code defined by a terminology system.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `system` string: String of characters used to identify a name or a resource
            - `version` string: A sequence of Unicode characters
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `display` string: A sequence of Unicode characters
            - `userSelected` boolean: Value of "true" or "false"
          - `text` string: A sequence of Unicode characters
        - `valueCoding` Coding: A reference to a code defined by a terminology system.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `system` string: String of characters used to identify a name or a resource
          - `version` string: A sequence of Unicode characters
          - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `display` string: A sequence of Unicode characters
          - `userSelected` boolean: Value of "true" or "false"
        - `valueContactPoint` ContactPoint: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `system` 'phone' | 'fax' | 'email' | 'pager' | 'url' | 'sms' | 'other': Telecommunications form for contact point - what communications system is required to make use of the contact.
          - `value` string: A sequence of Unicode characters
          - `use` 'home' | 'work' | 'temp' | 'old' | 'mobile': Identifies the purpose for the contact point.
          - `rank` number: An integer with a value that is positive (e.g. >0)
          - `period` Period: A time period defined by a start and end date and optionally time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
        - `valueCount` Count: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `value` number: A rational number with implicit precision
          - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
          - `unit` string: A sequence of Unicode characters
          - `system` string: String of characters used to identify a name or a resource
          - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueDistance` Distance: A length - a value with a unit that is a physical distance.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `value` number: A rational number with implicit precision
          - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
          - `unit` string: A sequence of Unicode characters
          - `system` string: String of characters used to identify a name or a resource
          - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueDuration` Duration: A length of time.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `value` number: A rational number with implicit precision
          - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
          - `unit` string: A sequence of Unicode characters
          - `system` string: String of characters used to identify a name or a resource
          - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueHumanName` HumanName: A human's name with the ability to identify parts and usage.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `use` 'usual' | 'official' | 'temp' | 'nickname' | 'anonymous' | 'old' | 'maiden': Identifies the purpose for this name.
          - `text` string: A sequence of Unicode characters
          - `family` string: A sequence of Unicode characters
          - `given` String[]: Given name.
          - `prefix` String[]: Part of the name that is acquired as a title due to academic, legal, employment or nobility status, etc. and that appears at the start of the name.
          - `suffix` String[]: Part of the name that is acquired as a title due to academic, legal, employment or nobility status, etc. and that appears at the end of the name.
          - `period` Period: A time period defined by a start and end date and optionally time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
        - `valueIdentifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `use` 'usual' | 'official' | 'temp' | 'secondary' | 'old': The purpose of this identifier.
          - `type` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `system` string: String of characters used to identify a name or a resource
          - `value` string: A sequence of Unicode characters
          - `period` Period: A time period defined by a start and end date and optionally time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `assigner` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier (recursive)
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
        - `valueMoney` Money: An amount of economic utility in some recognized currency.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `value` number: A rational number with implicit precision
          - `currency` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valuePeriod` Period: A time period defined by a start and end date and optionally time.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
        - `valueQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `value` number: A rational number with implicit precision
          - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
          - `unit` string: A sequence of Unicode characters
          - `system` string: String of characters used to identify a name or a resource
          - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueRange` Range: A set of ordered Quantities defined by a low and high limit.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `low` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `high` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueRatio` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `numerator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `denominator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueReference` Reference: A reference from one resource to another.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `reference` string: A sequence of Unicode characters
          - `type` string: String of characters used to identify a name or a resource
          - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'usual' | 'official' | 'temp' | 'secondary' | 'old': The purpose of this identifier.
            - `type` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `system` string: String of characters used to identify a name or a resource
            - `value` string: A sequence of Unicode characters
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
            - `assigner` Reference (recursive)
          - `display` string: A sequence of Unicode characters
          - `resource` ResourceList (recursive)
        - `valueSampledData` SampledData: A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `origin` Quantity, required: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `period` number: A rational number with implicit precision
          - `factor` number: A rational number with implicit precision
          - `lowerLimit` number: A rational number with implicit precision
          - `upperLimit` number: A rational number with implicit precision
          - `dimensions` number: An integer with a value that is positive (e.g. >0)
          - `data` string: A sequence of Unicode characters
        - `valueSignature` Signature: A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `type` Coding[], required: An indication of the reason that the entity signed this document. This may be explicitly included as part of the signature information and can be used when determining accountability for various actions concerning the document.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `system` string: String of characters used to identify a name or a resource
            - `version` string: A sequence of Unicode characters
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `display` string: A sequence of Unicode characters
            - `userSelected` boolean: Value of "true" or "false"
          - `when` string: An instant in time - known at least to the second
          - `who` Reference, required: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `onBehalfOf` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `targetFormat` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `sigFormat` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `data` string: A stream of bytes
        - `valueTiming` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `modifierExtension` 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).
          - `event` DateTime[]: Identifies specific times when the event occurs.
          - `repeat` TimingRepeat: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `boundsDuration` Duration: A length of time.
              - …
            - `boundsRange` Range: A set of ordered Quantities defined by a low and high limit.
              - …
            - `boundsPeriod` Period: A time period defined by a start and end date and optionally time.
              - …
            - `count` number: An integer with a value that is positive (e.g. >0)
            - `countMax` number: An integer with a value that is positive (e.g. >0)
            - `duration` number: A rational number with implicit precision
            - `durationMax` number: A rational number with implicit precision
            - `durationUnit` 's' | 'min' | 'h' | 'd' | 'wk' | 'mo' | 'a': The units of time for the duration, in UCUM units.
            - `frequency` number: An integer with a value that is positive (e.g. >0)
            - `frequencyMax` number: An integer with a value that is positive (e.g. >0)
            - `period` number: A rational number with implicit precision
            - `periodMax` number: A rational number with implicit precision
            - `periodUnit` 's' | 'min' | 'h' | 'd' | 'wk' | 'mo' | 'a': The units of time for the period in UCUM units.
            - `dayOfWeek` Code[]: If one or more days of week is provided, then the action happens only on the specified day(s).
            - `timeOfDay` Time[]: Specified time of day for action to take place.
            - `when` string[]: An approximate time period during the day, potentially linked to an event of daily living that indicates when the action should occur.
            - `offset` number: An integer with a value that is not negative (e.g. >= 0)
          - `code` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
        - `valueContactDetail` ContactDetail: Specifies contact information for a person or organization.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `name` string: A sequence of Unicode characters
          - `telecom` ContactPoint[]: The contact details for the individual (if a name was provided) or the organization.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `system` 'phone' | 'fax' | 'email' | 'pager' | 'url' | 'sms' | 'other': Telecommunications form for contact point - what communications system is required to make use of the contact.
            - `value` string: A sequence of Unicode characters
            - `use` 'home' | 'work' | 'temp' | 'old' | 'mobile': Identifies the purpose for the contact point.
            - `rank` number: An integer with a value that is positive (e.g. >0)
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
        - `valueContributor` Contributor: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `type` 'author' | 'editor' | 'reviewer' | 'endorser': The type of contributor.
          - `name` string: A sequence of Unicode characters
          - `contact` ContactDetail[]: Contact details to assist a user in finding and communicating with the contributor.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `name` string: A sequence of Unicode characters
            - `telecom` ContactPoint[]: The contact details for the individual (if a name was provided) or the organization.
              - …
        - `valueDataRequirement` DataRequirement: Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `profile` Canonical[]: The profile of the required data, specified as the uri of the profile definition.
          - `subjectCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `subjectReference` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `mustSupport` String[]: Indicates that specific elements of the type are referenced by the knowledge module and must be supported by the consumer in order to obtain an effective evaluation. This does not mean that a value is required for this element, only that the consuming system must understand the element and be able to provide values for it if they are available. The value of mustSupport SHALL be a FHIRPath resolveable on the type of the DataRequirement. The path SHALL consist only of identifiers, constant indexers, and .resolve() (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details).
          - `codeFilter` DataRequirementCodeFilter[]: Code filters specify additional constraints on the data, specifying the value set of interest for a particular element of the data. Each code filter defines an additional constraint on the data, i.e. code filters are AND'ed, not OR'ed.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `path` string: A sequence of Unicode characters
            - `searchParam` string: A sequence of Unicode characters
            - `valueSet` string: A URI that is a reference to a canonical URL on a FHIR resource
            - `code` Coding[]: The codes for the code filter. If values are given, the filter will return only those data items for which the code-valued attribute specified by the path has a value that is one of the specified codes. If codes are specified in addition to a value set, the filter returns items matching a code in the value set or one of the specified codes.
              - …
          - `dateFilter` DataRequirementDateFilter[]: Date filters specify additional constraints on the data in terms of the applicable date range for specific elements. Each date filter specifies an additional constraint on the data, i.e. date filters are AND'ed, not OR'ed.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `path` string: A sequence of Unicode characters
            - `searchParam` string: A sequence of Unicode characters
            - `valueDateTime` string: The value of the filter. If period is specified, the filter will return only those data items that fall within the bounds determined by the Period, inclusive of the period boundaries. If dateTime is specified, the filter will return only those data items that are equal to the specified dateTime. If a Duration is specified, the filter will return only those data items that fall within Duration before now.
            - `valuePeriod` Period: A time period defined by a start and end date and optionally time.
              - …
            - `valueDuration` Duration: A length of time.
              - …
          - `limit` number: An integer with a value that is positive (e.g. >0)
          - `sort` DataRequirementSort[]: Specifies the order of the results to be returned.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `path` string: A sequence of Unicode characters
            - `direction` 'ascending' | 'descending': The direction of the sort, ascending or descending.
        - `valueExpression` Expression: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `description` string: A sequence of Unicode characters
          - `name` string: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive.
          - `language` 'text/cql' | 'text/fhirpath' | 'application/x-fhir-query': The media type of the language for the expression.
          - `expression` string: A sequence of Unicode characters
          - `reference` string: String of characters used to identify a name or a resource
        - `valueParameterDefinition` ParameterDefinition: The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `name` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `use` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `min` number: A whole number
          - `max` string: A sequence of Unicode characters
          - `documentation` string: A sequence of Unicode characters
          - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `profile` string: A URI that is a reference to a canonical URL on a FHIR resource
        - `valueRelatedArtifact` RelatedArtifact: Related artifacts such as additional documentation, justification, or bibliographic references.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `type` 'documentation' | 'justification' | 'citation' | 'predecessor' | 'successor' | 'derived-from' | 'depends-on' | 'composed-of': The type of relationship to the related artifact.
          - `label` string: A sequence of Unicode characters
          - `display` string: A sequence of Unicode characters
          - `citation` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
          - `url` string: A URI that is a literal reference
          - `document` Attachment: For referring to data content defined in other formats.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `contentType` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `language` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `data` string: A stream of bytes
            - `url` string: A URI that is a literal reference
            - `size` number: An integer with a value that is not negative (e.g. >= 0)
            - `hash` string: A stream of bytes
            - `title` string: A sequence of Unicode characters
            - `creation` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `resource` string: A URI that is a reference to a canonical URL on a FHIR resource
        - `valueTriggerDefinition` TriggerDefinition: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `type` 'named-event' | 'periodic' | 'data-changed' | 'data-added' | 'data-modified' | 'data-removed' | 'data-accessed' | 'data-access-ended': The type of triggering event.
          - `name` string: A sequence of Unicode characters
          - `timingTiming` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `event` DateTime[]: Identifies specific times when the event occurs.
            - `repeat` TimingRepeat: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `code` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
          - `timingReference` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `timingDate` string: The timing of the event (if this is a periodic trigger).
          - `timingDateTime` string: The timing of the event (if this is a periodic trigger).
          - `data` DataRequirement[]: The triggering data of the event (if this is a data trigger). If more than one data is requirement is specified, then all the data requirements must be true.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `profile` Canonical[]: The profile of the required data, specified as the uri of the profile definition.
            - `subjectCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `subjectReference` Reference: A reference from one resource to another.
              - …
            - `mustSupport` String[]: Indicates that specific elements of the type are referenced by the knowledge module and must be supported by the consumer in order to obtain an effective evaluation. This does not mean that a value is required for this element, only that the consuming system must understand the element and be able to provide values for it if they are available. The value of mustSupport SHALL be a FHIRPath resolveable on the type of the DataRequirement. The path SHALL consist only of identifiers, constant indexers, and .resolve() (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details).
            - `codeFilter` DataRequirementCodeFilter[]: Code filters specify additional constraints on the data, specifying the value set of interest for a particular element of the data. Each code filter defines an additional constraint on the data, i.e. code filters are AND'ed, not OR'ed.
              - …
            - `dateFilter` DataRequirementDateFilter[]: Date filters specify additional constraints on the data in terms of the applicable date range for specific elements. Each date filter specifies an additional constraint on the data, i.e. date filters are AND'ed, not OR'ed.
              - …
            - `limit` number: An integer with a value that is positive (e.g. >0)
            - `sort` DataRequirementSort[]: Specifies the order of the results to be returned.
              - …
          - `condition` Expression: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `description` string: A sequence of Unicode characters
            - `name` string: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive.
            - `language` 'text/cql' | 'text/fhirpath' | 'application/x-fhir-query': The media type of the language for the expression.
            - `expression` string: A sequence of Unicode characters
            - `reference` string: String of characters used to identify a name or a resource
        - `valueUsageContext` UsageContext: Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `code` Coding, required: A reference to a code defined by a terminology system.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `system` string: String of characters used to identify a name or a resource
            - `version` string: A sequence of Unicode characters
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `display` string: A sequence of Unicode characters
            - `userSelected` boolean: Value of "true" or "false"
          - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `valueQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueRange` Range: A set of ordered Quantities defined by a low and high limit.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `low` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `high` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueReference` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
        - `valueDosage` Dosage: Indicates how the medication is/was taken or should be taken by the patient.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `modifierExtension` 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).
          - `sequence` number: A whole number
          - `text` string: A sequence of Unicode characters
          - `additionalInstruction` CodeableConcept[]: Supplemental instructions to the patient on how to take the medication (e.g. "with meals" or"take half to one hour before food") or warnings for the patient about the medication (e.g. "may cause drowsiness" or "avoid exposure of skin to direct sunlight or sunlamps").
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `patientInstruction` string: A sequence of Unicode characters
          - `timing` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `event` DateTime[]: Identifies specific times when the event occurs.
            - `repeat` TimingRepeat: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `code` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
          - `asNeededBoolean` boolean: Indicates whether the Medication is only taken when needed within a specific dosing schedule (Boolean option), or it indicates the precondition for taking the Medication (CodeableConcept).
          - `asNeededCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `site` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `route` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `method` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
              - …
            - `text` string: A sequence of Unicode characters
          - `doseAndRate` DosageDoseAndRate[]: The amount of medication administered.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `type` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `doseRange` Range: A set of ordered Quantities defined by a low and high limit.
              - …
            - `doseQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `rateRatio` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
              - …
            - `rateRange` Range: A set of ordered Quantities defined by a low and high limit.
              - …
            - `rateQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `maxDosePerPeriod` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `numerator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `denominator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `maxDosePerAdministration` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `maxDosePerLifetime` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `valueMeta` Meta (recursive)
      - `versionId` string: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive.
      - `lastUpdated` string: An instant in time - known at least to the second
      - `source` string: String of characters used to identify a name or a resource
      - `profile` Canonical[]: A list of profiles (references to [[[StructureDefinition]]] resources) that this resource claims to conform to. The URL is a reference to [[[StructureDefinition.url]]].
      - `security` Coding[]: Security labels applied to this resource. These tags connect specific resources to the overall security policy and infrastructure.
        - `id` string: A sequence of Unicode characters
        - `extension` Extension[]: 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.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `url` string: String of characters used to identify a name or a resource
          - `valueBase64Binary` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueBoolean` boolean: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueCanonical` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueCode` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDate` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDateTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDecimal` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueId` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueInstant` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueInteger` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueMarkdown` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueOid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valuePositiveInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueString` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUnsignedInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUri` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUrl` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUuid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueAddress` Address: An address expressed using postal conventions (as opposed to GPS or other location definition formats). This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery. There are a variety of postal address formats defined around the world.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'home' | 'work' | 'temp' | 'old' | 'billing': The purpose of this address.
            - `type` 'postal' | 'physical' | 'both': Distinguishes between physical addresses (those you can visit) and mailing addresses (e.g. PO Boxes and care-of addresses). Most addresses are both.
            - `text` string: A sequence of Unicode characters
            - `line` String[]: This component contains the house number, apartment number, street name, street direction, P.O. Box number, delivery hints, and similar address information.
            - `city` string: A sequence of Unicode characters
            - `district` string: A sequence of Unicode characters
            - `state` string: A sequence of Unicode characters
            - `postalCode` string: A sequence of Unicode characters
            - `country` string: A sequence of Unicode characters
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueAge` Age: A duration of time during which an organism (or a process) has existed.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueAnnotation` Annotation: A text note which also contains information about who made the statement and when.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `authorReference` Reference: A reference from one resource to another.
              - …
            - `authorString` string: The individual responsible for making the annotation.
            - `time` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `text` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
          - `valueAttachment` Attachment: For referring to data content defined in other formats.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `contentType` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `language` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `data` string: A stream of bytes
            - `url` string: A URI that is a literal reference
            - `size` number: An integer with a value that is not negative (e.g. >= 0)
            - `hash` string: A stream of bytes
            - `title` string: A sequence of Unicode characters
            - `creation` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
            - `text` string: A sequence of Unicode characters
          - `valueCoding` Coding (recursive)
          - `valueContactPoint` ContactPoint: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `system` 'phone' | 'fax' | 'email' | 'pager' | 'url' | 'sms' | 'other': Telecommunications form for contact point - what communications system is required to make use of the contact.
            - `value` string: A sequence of Unicode characters
            - `use` 'home' | 'work' | 'temp' | 'old' | 'mobile': Identifies the purpose for the contact point.
            - `rank` number: An integer with a value that is positive (e.g. >0)
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueCount` Count: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueDistance` Distance: A length - a value with a unit that is a physical distance.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueDuration` Duration: A length of time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueHumanName` HumanName: A human's name with the ability to identify parts and usage.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'usual' | 'official' | 'temp' | 'nickname' | 'anonymous' | 'old' | 'maiden': Identifies the purpose for this name.
            - `text` string: A sequence of Unicode characters
            - `family` string: A sequence of Unicode characters
            - `given` String[]: Given name.
            - `prefix` String[]: Part of the name that is acquired as a title due to academic, legal, employment or nobility status, etc. and that appears at the start of the name.
            - `suffix` String[]: Part of the name that is acquired as a title due to academic, legal, employment or nobility status, etc. and that appears at the end of the name.
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueIdentifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'usual' | 'official' | 'temp' | 'secondary' | 'old': The purpose of this identifier.
            - `type` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `system` string: String of characters used to identify a name or a resource
            - `value` string: A sequence of Unicode characters
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
            - `assigner` Reference: A reference from one resource to another.
              - …
          - `valueMoney` Money: An amount of economic utility in some recognized currency.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `currency` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valuePeriod` Period: A time period defined by a start and end date and optionally time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `valueQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueRange` Range: A set of ordered Quantities defined by a low and high limit.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `low` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `high` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueRatio` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `numerator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `denominator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueReference` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `valueSampledData` SampledData: A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `origin` Quantity, required: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `period` number: A rational number with implicit precision
            - `factor` number: A rational number with implicit precision
            - `lowerLimit` number: A rational number with implicit precision
            - `upperLimit` number: A rational number with implicit precision
            - `dimensions` number: An integer with a value that is positive (e.g. >0)
            - `data` string: A sequence of Unicode characters
          - `valueSignature` Signature: A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` Coding[], required: An indication of the reason that the entity signed this document. This may be explicitly included as part of the signature information and can be used when determining accountability for various actions concerning the document.
            - `when` string: An instant in time - known at least to the second
            - `who` Reference, required: A reference from one resource to another.
              - …
            - `onBehalfOf` Reference: A reference from one resource to another.
              - …
            - `targetFormat` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `sigFormat` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `data` string: A stream of bytes
          - `valueTiming` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `event` DateTime[]: Identifies specific times when the event occurs.
            - `repeat` TimingRepeat: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `code` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
          - `valueContactDetail` ContactDetail: Specifies contact information for a person or organization.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `name` string: A sequence of Unicode characters
            - `telecom` ContactPoint[]: The contact details for the individual (if a name was provided) or the organization.
              - …
          - `valueContributor` Contributor: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` 'author' | 'editor' | 'reviewer' | 'endorser': The type of contributor.
            - `name` string: A sequence of Unicode characters
            - `contact` ContactDetail[]: Contact details to assist a user in finding and communicating with the contributor.
              - …
          - `valueDataRequirement` DataRequirement: Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `profile` Canonical[]: The profile of the required data, specified as the uri of the profile definition.
            - `subjectCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `subjectReference` Reference: A reference from one resource to another.
              - …
            - `mustSupport` String[]: Indicates that specific elements of the type are referenced by the knowledge module and must be supported by the consumer in order to obtain an effective evaluation. This does not mean that a value is required for this element, only that the consuming system must understand the element and be able to provide values for it if they are available. The value of mustSupport SHALL be a FHIRPath resolveable on the type of the DataRequirement. The path SHALL consist only of identifiers, constant indexers, and .resolve() (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details).
            - `codeFilter` DataRequirementCodeFilter[]: Code filters specify additional constraints on the data, specifying the value set of interest for a particular element of the data. Each code filter defines an additional constraint on the data, i.e. code filters are AND'ed, not OR'ed.
              - …
            - `dateFilter` DataRequirementDateFilter[]: Date filters specify additional constraints on the data in terms of the applicable date range for specific elements. Each date filter specifies an additional constraint on the data, i.e. date filters are AND'ed, not OR'ed.
              - …
            - `limit` number: An integer with a value that is positive (e.g. >0)
            - `sort` DataRequirementSort[]: Specifies the order of the results to be returned.
              - …
          - `valueExpression` Expression: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `description` string: A sequence of Unicode characters
            - `name` string: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive.
            - `language` 'text/cql' | 'text/fhirpath' | 'application/x-fhir-query': The media type of the language for the expression.
            - `expression` string: A sequence of Unicode characters
            - `reference` string: String of characters used to identify a name or a resource
          - `valueParameterDefinition` ParameterDefinition: The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `name` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `use` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `min` number: A whole number
            - `max` string: A sequence of Unicode characters
            - `documentation` string: A sequence of Unicode characters
            - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `profile` string: A URI that is a reference to a canonical URL on a FHIR resource
          - `valueRelatedArtifact` RelatedArtifact: Related artifacts such as additional documentation, justification, or bibliographic references.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` 'documentation' | 'justification' | 'citation' | 'predecessor' | 'successor' | 'derived-from' | 'depends-on' | 'composed-of': The type of relationship to the related artifact.
            - `label` string: A sequence of Unicode characters
            - `display` string: A sequence of Unicode characters
            - `citation` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
            - `url` string: A URI that is a literal reference
            - `document` Attachment: For referring to data content defined in other formats.
              - …
            - `resource` string: A URI that is a reference to a canonical URL on a FHIR resource
          - `valueTriggerDefinition` TriggerDefinition: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` 'named-event' | 'periodic' | 'data-changed' | 'data-added' | 'data-modified' | 'data-removed' | 'data-accessed' | 'data-access-ended': The type of triggering event.
            - `name` string: A sequence of Unicode characters
            - `timingTiming` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `timingReference` Reference: A reference from one resource to another.
              - …
            - `timingDate` string: The timing of the event (if this is a periodic trigger).
            - `timingDateTime` string: The timing of the event (if this is a periodic trigger).
            - `data` DataRequirement[]: The triggering data of the event (if this is a data trigger). If more than one data is requirement is specified, then all the data requirements must be true.
              - …
            - `condition` Expression: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
              - …
          - `valueUsageContext` UsageContext: Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `code` Coding, required (recursive)
            - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `valueQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `valueRange` Range: A set of ordered Quantities defined by a low and high limit.
              - …
            - `valueReference` Reference: A reference from one resource to another.
              - …
          - `valueDosage` Dosage: Indicates how the medication is/was taken or should be taken by the patient.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `sequence` number: A whole number
            - `text` string: A sequence of Unicode characters
            - `additionalInstruction` CodeableConcept[]: Supplemental instructions to the patient on how to take the medication (e.g. "with meals" or"take half to one hour before food") or warnings for the patient about the medication (e.g. "may cause drowsiness" or "avoid exposure of skin to direct sunlight or sunlamps").
              - …
            - `patientInstruction` string: A sequence of Unicode characters
            - `timing` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `asNeededBoolean` boolean: Indicates whether the Medication is only taken when needed within a specific dosing schedule (Boolean option), or it indicates the precondition for taking the Medication (CodeableConcept).
            - `asNeededCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `site` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `route` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `method` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `doseAndRate` DosageDoseAndRate[]: The amount of medication administered.
              - …
            - `maxDosePerPeriod` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
              - …
            - `maxDosePerAdministration` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `maxDosePerLifetime` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueMeta` Meta (recursive)
        - `system` string: String of characters used to identify a name or a resource
        - `version` string: A sequence of Unicode characters
        - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `display` string: A sequence of Unicode characters
        - `userSelected` boolean: Value of "true" or "false"
      - `tag` Coding[]: Tags applied to this resource. Tags are intended to be used to identify and relate resources to process and workflow, and applications are not required to consider the tags when interpreting the meaning of a resource.
        - `id` string: A sequence of Unicode characters
        - `extension` Extension[]: 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.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `url` string: String of characters used to identify a name or a resource
          - `valueBase64Binary` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueBoolean` boolean: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueCanonical` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueCode` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDate` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDateTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDecimal` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueId` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueInstant` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueInteger` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueMarkdown` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueOid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valuePositiveInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueString` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUnsignedInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUri` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUrl` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUuid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueAddress` Address: An address expressed using postal conventions (as opposed to GPS or other location definition formats). This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery. There are a variety of postal address formats defined around the world.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'home' | 'work' | 'temp' | 'old' | 'billing': The purpose of this address.
            - `type` 'postal' | 'physical' | 'both': Distinguishes between physical addresses (those you can visit) and mailing addresses (e.g. PO Boxes and care-of addresses). Most addresses are both.
            - `text` string: A sequence of Unicode characters
            - `line` String[]: This component contains the house number, apartment number, street name, street direction, P.O. Box number, delivery hints, and similar address information.
            - `city` string: A sequence of Unicode characters
            - `district` string: A sequence of Unicode characters
            - `state` string: A sequence of Unicode characters
            - `postalCode` string: A sequence of Unicode characters
            - `country` string: A sequence of Unicode characters
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueAge` Age: A duration of time during which an organism (or a process) has existed.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueAnnotation` Annotation: A text note which also contains information about who made the statement and when.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `authorReference` Reference: A reference from one resource to another.
              - …
            - `authorString` string: The individual responsible for making the annotation.
            - `time` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `text` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
          - `valueAttachment` Attachment: For referring to data content defined in other formats.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `contentType` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `language` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `data` string: A stream of bytes
            - `url` string: A URI that is a literal reference
            - `size` number: An integer with a value that is not negative (e.g. >= 0)
            - `hash` string: A stream of bytes
            - `title` string: A sequence of Unicode characters
            - `creation` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `coding` Coding[]: A reference to a code defined by a terminology system.
            - `text` string: A sequence of Unicode characters
          - `valueCoding` Coding (recursive)
          - `valueContactPoint` ContactPoint: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `system` 'phone' | 'fax' | 'email' | 'pager' | 'url' | 'sms' | 'other': Telecommunications form for contact point - what communications system is required to make use of the contact.
            - `value` string: A sequence of Unicode characters
            - `use` 'home' | 'work' | 'temp' | 'old' | 'mobile': Identifies the purpose for the contact point.
            - `rank` number: An integer with a value that is positive (e.g. >0)
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueCount` Count: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueDistance` Distance: A length - a value with a unit that is a physical distance.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueDuration` Duration: A length of time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueHumanName` HumanName: A human's name with the ability to identify parts and usage.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'usual' | 'official' | 'temp' | 'nickname' | 'anonymous' | 'old' | 'maiden': Identifies the purpose for this name.
            - `text` string: A sequence of Unicode characters
            - `family` string: A sequence of Unicode characters
            - `given` String[]: Given name.
            - `prefix` String[]: Part of the name that is acquired as a title due to academic, legal, employment or nobility status, etc. and that appears at the start of the name.
            - `suffix` String[]: Part of the name that is acquired as a title due to academic, legal, employment or nobility status, etc. and that appears at the end of the name.
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueIdentifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'usual' | 'official' | 'temp' | 'secondary' | 'old': The purpose of this identifier.
            - `type` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `system` string: String of characters used to identify a name or a resource
            - `value` string: A sequence of Unicode characters
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
            - `assigner` Reference: A reference from one resource to another.
              - …
          - `valueMoney` Money: An amount of economic utility in some recognized currency.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `currency` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valuePeriod` Period: A time period defined by a start and end date and optionally time.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `start` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `end` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `valueQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueRange` Range: A set of ordered Quantities defined by a low and high limit.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `low` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `high` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueRatio` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `numerator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `denominator` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueReference` Reference: A reference from one resource to another.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `reference` string: A sequence of Unicode characters
            - `type` string: String of characters used to identify a name or a resource
            - `identifier` Identifier: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
              - …
            - `display` string: A sequence of Unicode characters
            - `resource` ResourceList (recursive)
          - `valueSampledData` SampledData: A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `origin` Quantity, required: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `period` number: A rational number with implicit precision
            - `factor` number: A rational number with implicit precision
            - `lowerLimit` number: A rational number with implicit precision
            - `upperLimit` number: A rational number with implicit precision
            - `dimensions` number: An integer with a value that is positive (e.g. >0)
            - `data` string: A sequence of Unicode characters
          - `valueSignature` Signature: A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` Coding[], required: An indication of the reason that the entity signed this document. This may be explicitly included as part of the signature information and can be used when determining accountability for various actions concerning the document.
            - `when` string: An instant in time - known at least to the second
            - `who` Reference, required: A reference from one resource to another.
              - …
            - `onBehalfOf` Reference: A reference from one resource to another.
              - …
            - `targetFormat` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `sigFormat` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `data` string: A stream of bytes
          - `valueTiming` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `event` DateTime[]: Identifies specific times when the event occurs.
            - `repeat` TimingRepeat: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `code` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
          - `valueContactDetail` ContactDetail: Specifies contact information for a person or organization.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `name` string: A sequence of Unicode characters
            - `telecom` ContactPoint[]: The contact details for the individual (if a name was provided) or the organization.
              - …
          - `valueContributor` Contributor: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` 'author' | 'editor' | 'reviewer' | 'endorser': The type of contributor.
            - `name` string: A sequence of Unicode characters
            - `contact` ContactDetail[]: Contact details to assist a user in finding and communicating with the contributor.
              - …
          - `valueDataRequirement` DataRequirement: Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `profile` Canonical[]: The profile of the required data, specified as the uri of the profile definition.
            - `subjectCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `subjectReference` Reference: A reference from one resource to another.
              - …
            - `mustSupport` String[]: Indicates that specific elements of the type are referenced by the knowledge module and must be supported by the consumer in order to obtain an effective evaluation. This does not mean that a value is required for this element, only that the consuming system must understand the element and be able to provide values for it if they are available. The value of mustSupport SHALL be a FHIRPath resolveable on the type of the DataRequirement. The path SHALL consist only of identifiers, constant indexers, and .resolve() (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details).
            - `codeFilter` DataRequirementCodeFilter[]: Code filters specify additional constraints on the data, specifying the value set of interest for a particular element of the data. Each code filter defines an additional constraint on the data, i.e. code filters are AND'ed, not OR'ed.
              - …
            - `dateFilter` DataRequirementDateFilter[]: Date filters specify additional constraints on the data in terms of the applicable date range for specific elements. Each date filter specifies an additional constraint on the data, i.e. date filters are AND'ed, not OR'ed.
              - …
            - `limit` number: An integer with a value that is positive (e.g. >0)
            - `sort` DataRequirementSort[]: Specifies the order of the results to be returned.
              - …
          - `valueExpression` Expression: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `description` string: A sequence of Unicode characters
            - `name` string: Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive.
            - `language` 'text/cql' | 'text/fhirpath' | 'application/x-fhir-query': The media type of the language for the expression.
            - `expression` string: A sequence of Unicode characters
            - `reference` string: String of characters used to identify a name or a resource
          - `valueParameterDefinition` ParameterDefinition: The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `name` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `use` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `min` number: A whole number
            - `max` string: A sequence of Unicode characters
            - `documentation` string: A sequence of Unicode characters
            - `type` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `profile` string: A URI that is a reference to a canonical URL on a FHIR resource
          - `valueRelatedArtifact` RelatedArtifact: Related artifacts such as additional documentation, justification, or bibliographic references.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` 'documentation' | 'justification' | 'citation' | 'predecessor' | 'successor' | 'derived-from' | 'depends-on' | 'composed-of': The type of relationship to the related artifact.
            - `label` string: A sequence of Unicode characters
            - `display` string: A sequence of Unicode characters
            - `citation` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
            - `url` string: A URI that is a literal reference
            - `document` Attachment: For referring to data content defined in other formats.
              - …
            - `resource` string: A URI that is a reference to a canonical URL on a FHIR resource
          - `valueTriggerDefinition` TriggerDefinition: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `type` 'named-event' | 'periodic' | 'data-changed' | 'data-added' | 'data-modified' | 'data-removed' | 'data-accessed' | 'data-access-ended': The type of triggering event.
            - `name` string: A sequence of Unicode characters
            - `timingTiming` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `timingReference` Reference: A reference from one resource to another.
              - …
            - `timingDate` string: The timing of the event (if this is a periodic trigger).
            - `timingDateTime` string: The timing of the event (if this is a periodic trigger).
            - `data` DataRequirement[]: The triggering data of the event (if this is a data trigger). If more than one data is requirement is specified, then all the data requirements must be true.
              - …
            - `condition` Expression: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
              - …
          - `valueUsageContext` UsageContext: Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `code` Coding, required (recursive)
            - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `valueQuantity` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `valueRange` Range: A set of ordered Quantities defined by a low and high limit.
              - …
            - `valueReference` Reference: A reference from one resource to another.
              - …
          - `valueDosage` Dosage: Indicates how the medication is/was taken or should be taken by the patient.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `modifierExtension` 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).
            - `sequence` number: A whole number
            - `text` string: A sequence of Unicode characters
            - `additionalInstruction` CodeableConcept[]: Supplemental instructions to the patient on how to take the medication (e.g. "with meals" or"take half to one hour before food") or warnings for the patient about the medication (e.g. "may cause drowsiness" or "avoid exposure of skin to direct sunlight or sunlamps").
              - …
            - `patientInstruction` string: A sequence of Unicode characters
            - `timing` Timing: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
              - …
            - `asNeededBoolean` boolean: Indicates whether the Medication is only taken when needed within a specific dosing schedule (Boolean option), or it indicates the precondition for taking the Medication (CodeableConcept).
            - `asNeededCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `site` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `route` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `method` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
              - …
            - `doseAndRate` DosageDoseAndRate[]: The amount of medication administered.
              - …
            - `maxDosePerPeriod` Ratio: A relationship of two Quantity values - expressed as a numerator and a denominator.
              - …
            - `maxDosePerAdministration` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
            - `maxDosePerLifetime` Quantity: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
              - …
          - `valueMeta` Meta (recursive)
        - `system` string: String of characters used to identify a name or a resource
        - `version` string: A sequence of Unicode characters
        - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
        - `display` string: A sequence of Unicode characters
        - `userSelected` boolean: Value of "true" or "false"
      - `project` string: String of characters used to identify a name or a resource
      - `author` Reference: A reference from one resource to another.
        - `id` string: A sequence of Unicode characters
        - `extension` Extension[]: 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.
          - `id` string: A sequence of Unicode characters
          - `extension` Extension[]: 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.
          - `url` string: String of characters used to identify a name or a resource
          - `valueBase64Binary` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueBoolean` boolean: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueCanonical` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueCode` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDate` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDateTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueDecimal` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueId` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueInstant` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueInteger` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueMarkdown` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueOid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valuePositiveInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueString` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueTime` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUnsignedInt` number: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUri` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUrl` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueUuid` string: Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).
          - `valueAddress` Address: An address expressed using postal conventions (as opposed to GPS or other location definition formats). This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery. There are a variety of postal address formats defined around the world.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `use` 'home' | 'work' | 'temp' | 'old' | 'billing': The purpose of this address.
            - `type` 'postal' | 'physical' | 'both': Distinguishes between physical addresses (those you can visit) and mailing addresses (e.g. PO Boxes and care-of addresses). Most addresses are both.
            - `text` string: A sequence of Unicode characters
            - `line` String[]: This component contains the house number, apartment number, street name, street direction, P.O. Box number, delivery hints, and similar address information.
            - `city` string: A sequence of Unicode characters
            - `district` string: A sequence of Unicode characters
            - `state` string: A sequence of Unicode characters
            - `postalCode` string: A sequence of Unicode characters
            - `country` string: A sequence of Unicode characters
            - `period` Period: A time period defined by a start and end date and optionally time.
              - …
          - `valueAge` Age: A duration of time during which an organism (or a process) has existed.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `value` number: A rational number with implicit precision
            - `comparator` '<' | '<=' | '>=' | '>': How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
            - `unit` string: A sequence of Unicode characters
            - `system` string: String of characters used to identify a name or a resource
            - `code` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
          - `valueAnnotation` Annotation: A text note which also contains information about who made the statement and when.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `authorReference` Reference (recursive)
            - `authorString` string: The individual responsible for making the annotation.
            - `time` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
            - `text` string: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
          - `valueAttachment` Attachment: For referring to data content defined in other formats.
            - `id` string: A sequence of Unicode characters
            - `extension` Extension[]: 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.
            - `contentType` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `language` string: A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents
            - `data` string: A stream of bytes
            - `url` string: A URI that is a literal reference
            - `size` number: An integer with a value that is not negative (e.g. >= 0)
            - `hash` string: A stream of bytes
            - `title` string: A sequence of Unicode characters
            - `creation` string: A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates.
          - `valueCodeableConcept` CodeableConcept: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
- … truncated; see the full OpenAPI document linked below

## Other responses

- `201`: Matched no resources, so the resource was created
- `400`: Invalid resource, or resource ID does not match the matched resource
- `412`: Matched multiple resources, or If-Match failed; nothing is written

## Changes

- **2026-10-16** `041f7dc810ef`: 5 info
  - added the new optional request property `oneOf[#/components/schemas/Project]/active`
  - added the optional property `contained/items/oneOf[#/components/schemas/Project]/active` to the response with the `400` status
  - added the optional property `contained/items/oneOf[#/components/schemas/Project]/active` to the response with the `412` status
  - added the optional property `oneOf[#/components/schemas/Project]/active` to the response with the `200` status
  - …1 more
- **2026-10-13** `aed7435d10f2`: 4 warning, 1 info
  - added the new `archive` enum value to the `contained/items/oneOf[#/components/schemas/Project]/features/items/` response property for the response status `400`
  - added the new `archive` enum value to the `contained/items/oneOf[#/components/schemas/Project]/features/items/` response property for the response status `412`
  - added the new `archive` enum value to the `oneOf[#/components/schemas/Project]/features/items/` response property for the response status `200`
  - added the new `archive` enum value to the `oneOf[#/components/schemas/Project]/features/items/` response property for the response status `201`
  - …1 more
- **2026-10-10** `2ee112db7111`: 1 info
  - endpoint added

[Operation history](https://skmtc.dev/medplum/apis/medplum-openapi-3-0/changes/fhir/R4/:resourceType/put.md)

---

[API](https://skmtc.dev/medplum/apis/medplum-openapi-3-0.md) - [All operations](https://skmtc.dev/medplum/apis/medplum-openapi-3-0/llms.txt) - [OpenAPI document](https://skmtc.dev/medplum/apis/medplum-openapi-3-0/revisions/041f7dc810ef?raw)
