{ "$schema": "http://json-schema.org/draft-07/schema#", "$id": "https://schemata.openattestation.com/sg/gov/moh/fhir/4.0.1/lite-schema.json#", "title": "Lite FHIR schema for Notarise.gov.sg HealthCerts", "description": "see http://hl7.org/fhir/json.html#schema for information about the FHIR Json Schemas", "definitions": { "ResourceList": { "oneOf": [ { "$ref": "#/definitions/Bundle" }, { "$ref": "#/definitions/Device" }, { "$ref": "#/definitions/Observation" }, { "$ref": "#/definitions/Organization" }, { "$ref": "#/definitions/Patient" }, { "$ref": "#/definitions/Practitioner" }, { "$ref": "#/definitions/Specimen" } ] }, "Address": { "description": "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.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "use": { "description": "The purpose of this address.", "enum": ["home", "work", "temp", "old", "billing"] }, "type": { "description": "Distinguishes between physical addresses (those you can visit) and mailing addresses (e.g. PO Boxes and care-of addresses). Most addresses are both.", "enum": ["postal", "physical", "both"] }, "text": { "description": "Specifies the entire address as it should be displayed e.g. on a postal label. This may be provided instead of or as well as the specific parts.", "$ref": "#/definitions/string" }, "line": { "description": "This component contains the house number, apartment number, street name, street direction, P.O. Box number, delivery hints, and similar address information.", "items": { "$ref": "#/definitions/string" }, "type": "array" }, "city": { "description": "The name of the city, town, suburb, village or other community or delivery center.", "$ref": "#/definitions/string" }, "district": { "description": "The name of the administrative area (county).", "$ref": "#/definitions/string" }, "state": { "description": "Sub-unit of a country with limited sovereignty in a federally organized country. A code may be used if codes are in common use (e.g. US 2 letter state codes).", "$ref": "#/definitions/string" }, "postalCode": { "description": "A postal code designating a region defined by the postal service.", "$ref": "#/definitions/string" }, "country": { "description": "Country - a nation as commonly understood or generally accepted.", "$ref": "#/definitions/string" }, "period": { "description": "Time period when address was/is in use.", "$ref": "#/definitions/Period" } }, "additionalProperties": false }, "Age": { "description": "A duration of time during which an organism (or a process) has existed.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "value": { "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.", "$ref": "#/definitions/decimal" }, "comparator": { "description": "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.", "enum": ["<", "<=", ">=", ">"] }, "unit": { "description": "A human-readable form of the unit.", "$ref": "#/definitions/string" }, "system": { "description": "The identification of the system that provides the coded form of the unit.", "$ref": "#/definitions/uri" }, "code": { "description": "A computer processable form of the unit in some unit representation system.", "$ref": "#/definitions/code" } }, "additionalProperties": false }, "Annotation": { "description": "A text note which also contains information about who made the statement and when.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "authorReference": { "description": "The individual responsible for making the annotation.", "$ref": "#/definitions/Reference" }, "authorString": { "description": "The individual responsible for making the annotation.", "pattern": "^[ \\r\\n\\t\\S]+$", "type": "string" }, "time": { "description": "Indicates when this particular annotation was made.", "$ref": "#/definitions/dateTime" }, "text": { "description": "The text of the annotation in markdown format.", "$ref": "#/definitions/markdown" } }, "additionalProperties": false }, "Attachment": { "description": "For referring to data content defined in other formats.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "contentType": { "description": "Identifies the type of the data in the attachment and allows a method to be chosen to interpret or render the data. Includes mime type parameters such as charset where appropriate.", "$ref": "#/definitions/code" }, "language": { "description": "The human language of the content. The value can be any valid value according to BCP 47.", "$ref": "#/definitions/code" }, "data": { "description": "The actual data of the attachment - a sequence of bytes, base64 encoded.", "$ref": "#/definitions/base64Binary" }, "url": { "description": "A location where the data can be accessed.", "$ref": "#/definitions/url" }, "size": { "description": "The number of bytes of data that make up this attachment (before base64 encoding, if that is done).", "$ref": "#/definitions/unsignedInt" }, "hash": { "description": "The calculated hash of the data using SHA-1. Represented using base64.", "$ref": "#/definitions/base64Binary" }, "title": { "description": "A label or set of text to display in place of the data.", "$ref": "#/definitions/string" }, "creation": { "description": "The date that the attachment was first created.", "$ref": "#/definitions/dateTime" } }, "additionalProperties": false }, "Bundle": { "description": "A container for a collection of resources.", "properties": { "resourceType": { "description": "This is a Bundle resource", "const": "Bundle" }, "id": { "description": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.", "$ref": "#/definitions/id" }, "meta": { "description": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.", "$ref": "#/definitions/Meta" }, "implicitRules": { "description": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content. Often, this is a reference to an implementation guide that defines the special rules along with other profiles etc.", "$ref": "#/definitions/uri" }, "language": { "description": "The base language in which the resource is written.", "$ref": "#/definitions/code" }, "identifier": { "description": "A persistent identifier for the bundle that won't change as a bundle is copied from server to server.", "$ref": "#/definitions/Identifier" }, "type": { "description": "Indicates the purpose of this bundle - how it is intended to be used.", "enum": [ "document", "message", "transaction", "transaction-response", "batch", "batch-response", "history", "searchset", "collection" ] }, "timestamp": { "description": "The date/time that the bundle was assembled - i.e. when the resources were placed in the bundle.", "$ref": "#/definitions/instant" }, "total": { "description": "If a set of search matches, this is the total number of entries of type 'match' across all pages in the search. It does not include search.mode = 'include' or 'outcome' entries and it does not provide a count of the number of entries in the Bundle.", "$ref": "#/definitions/unsignedInt" }, "link": { "description": "A series of links that provide context to this bundle.", "items": { "$ref": "#/definitions/Bundle_Link" }, "type": "array" }, "entry": { "description": "An entry in a bundle resource - will either contain a resource or information about a resource (transactions and history only).", "items": { "$ref": "#/definitions/Bundle_Entry" }, "type": "array" }, "signature": { "description": "Digital Signature - base64 encoded. XML-DSig or a JWT.", "$ref": "#/definitions/Signature" } }, "additionalProperties": false, "required": ["resourceType"] }, "Bundle_Entry": { "description": "A container for a collection of resources.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "link": { "description": "A series of links that provide context to this entry.", "items": { "$ref": "#/definitions/Bundle_Link" }, "type": "array" }, "fullUrl": { "description": "The Absolute URL for the resource. The fullUrl SHALL NOT disagree with the id in the resource - i.e. if the fullUrl is not a urn:uuid, the URL shall be version-independent URL consistent with the Resource.id. The fullUrl is a version independent reference to the resource. The fullUrl element SHALL have a value except that: \n* fullUrl can be empty on a POST (although it does not need to when specifying a temporary id for reference in the bundle)\n* Results from operations might involve resources that are not identified.", "$ref": "#/definitions/uri" }, "resource": { "description": "The Resource for the entry. The purpose/meaning of the resource is determined by the Bundle.type.", "$ref": "#/definitions/ResourceList" }, "search": { "description": "Information about the search process that lead to the creation of this entry.", "$ref": "#/definitions/Bundle_Search" }, "request": { "description": "Additional information about how this entry should be processed as part of a transaction or batch. For history, it shows how the entry was processed to create the version contained in the entry.", "$ref": "#/definitions/Bundle_Request" }, "response": { "description": "Indicates the results of processing the corresponding 'request' entry in the batch or transaction being responded to or what the results of an operation where when returning history.", "$ref": "#/definitions/Bundle_Response" } }, "additionalProperties": false }, "Bundle_Link": { "description": "A container for a collection of resources.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "relation": { "description": "A name which details the functional use for this link - see [http://www.iana.org/assignments/link-relations/link-relations.xhtml#link-relations-1](http://www.iana.org/assignments/link-relations/link-relations.xhtml#link-relations-1).", "$ref": "#/definitions/string" }, "url": { "description": "The reference details for the link.", "$ref": "#/definitions/uri" } }, "additionalProperties": false }, "Bundle_Request": { "description": "A container for a collection of resources.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "method": { "description": "In a transaction or batch, this is the HTTP action to be executed for this entry. In a history bundle, this indicates the HTTP action that occurred.", "enum": ["GET", "HEAD", "POST", "PUT", "DELETE", "PATCH"] }, "url": { "description": "The URL for this entry, relative to the root (the address to which the request is posted).", "$ref": "#/definitions/uri" }, "ifNoneMatch": { "description": "If the ETag values match, return a 304 Not Modified status. See the API documentation for [\"Conditional Read\"](http.html#cread).", "$ref": "#/definitions/string" }, "ifModifiedSince": { "description": "Only perform the operation if the last updated date matches. See the API documentation for [\"Conditional Read\"](http.html#cread).", "$ref": "#/definitions/instant" }, "ifMatch": { "description": "Only perform the operation if the Etag value matches. For more information, see the API section [\"Managing Resource Contention\"](http.html#concurrency).", "$ref": "#/definitions/string" }, "ifNoneExist": { "description": "Instruct the server not to perform the create if a specified resource already exists. For further information, see the API documentation for [\"Conditional Create\"](http.html#ccreate). This is just the query portion of the URL - what follows the \"?\" (not including the \"?\").", "$ref": "#/definitions/string" } }, "additionalProperties": false }, "Bundle_Response": { "description": "A container for a collection of resources.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "status": { "description": "The status code returned by processing this entry. The status SHALL start with a 3 digit HTTP code (e.g. 404) and may contain the standard HTTP description associated with the status code.", "$ref": "#/definitions/string" }, "location": { "description": "The location header created by processing this operation, populated if the operation returns a location.", "$ref": "#/definitions/uri" }, "etag": { "description": "The Etag for the resource, if the operation for the entry produced a versioned resource (see [Resource Metadata and Versioning](http.html#versioning) and [Managing Resource Contention](http.html#concurrency)).", "$ref": "#/definitions/string" }, "lastModified": { "description": "The date/time that the resource was modified on the server.", "$ref": "#/definitions/instant" }, "outcome": { "description": "An OperationOutcome containing hints and warnings produced as part of processing this entry in a batch or transaction.", "$ref": "#/definitions/ResourceList" } }, "additionalProperties": false }, "Bundle_Search": { "description": "A container for a collection of resources.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "mode": { "description": "Why this entry is in the result set - whether it's included as a match or because of an _include requirement, or to convey information or warning information about the search process.", "enum": ["match", "include", "outcome"] }, "score": { "description": "When searching, the server's search ranking score for the entry.", "$ref": "#/definitions/decimal" } }, "additionalProperties": false }, "CodeableConcept": { "description": "A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "coding": { "description": "A reference to a code defined by a terminology system.", "items": { "$ref": "#/definitions/Coding" }, "type": "array" }, "text": { "description": "A human language representation of the concept as seen/selected/uttered by the user who entered the data and/or which represents the intended meaning of the user.", "$ref": "#/definitions/string" } }, "additionalProperties": false }, "Coding": { "description": "A reference to a code defined by a terminology system.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "system": { "description": "The identification of the code system that defines the meaning of the symbol in the code.", "$ref": "#/definitions/uri" }, "version": { "description": "The version of the code system which was used when choosing this code. Note that a well-maintained code system does not need the version reported, because the meaning of codes is consistent across versions. However this cannot consistently be assured, and when the meaning is not guaranteed to be consistent, the version SHOULD be exchanged.", "$ref": "#/definitions/string" }, "code": { "description": "A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination).", "$ref": "#/definitions/code" }, "display": { "description": "A representation of the meaning of the code in the system, following the rules of the system.", "$ref": "#/definitions/string" }, "userSelected": { "description": "Indicates that this coding was chosen by a user directly - e.g. off a pick list of available items (codes or displays).", "$ref": "#/definitions/boolean" } }, "additionalProperties": false }, "ContactDetail": { "description": "Specifies contact information for a person or organization.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "name": { "description": "The name of an individual to contact.", "$ref": "#/definitions/string" }, "telecom": { "description": "The contact details for the individual (if a name was provided) or the organization.", "items": { "$ref": "#/definitions/ContactPoint" }, "type": "array" } }, "additionalProperties": false }, "ContactPoint": { "description": "Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "system": { "description": "Telecommunications form for contact point - what communications system is required to make use of the contact.", "enum": ["phone", "fax", "email", "pager", "url", "sms", "other"] }, "value": { "description": "The actual contact point details, in a form that is meaningful to the designated communication system (i.e. phone number or email address).", "$ref": "#/definitions/string" }, "use": { "description": "Identifies the purpose for the contact point.", "enum": ["home", "work", "temp", "old", "mobile"] }, "rank": { "description": "Specifies a preferred order in which to use a set of contacts. ContactPoints with lower rank values are more preferred than those with higher rank values.", "$ref": "#/definitions/positiveInt" }, "period": { "description": "Time period when the contact point was/is in use.", "$ref": "#/definitions/Period" } }, "additionalProperties": false }, "Contributor": { "description": "A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "type": { "description": "The type of contributor.", "enum": ["author", "editor", "reviewer", "endorser"] }, "name": { "description": "The name of the individual or organization responsible for the contribution.", "$ref": "#/definitions/string" }, "contact": { "description": "Contact details to assist a user in finding and communicating with the contributor.", "items": { "$ref": "#/definitions/ContactDetail" }, "type": "array" } }, "additionalProperties": false }, "Count": { "description": "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.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "value": { "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.", "$ref": "#/definitions/decimal" }, "comparator": { "description": "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.", "enum": ["<", "<=", ">=", ">"] }, "unit": { "description": "A human-readable form of the unit.", "$ref": "#/definitions/string" }, "system": { "description": "The identification of the system that provides the coded form of the unit.", "$ref": "#/definitions/uri" }, "code": { "description": "A computer processable form of the unit in some unit representation system.", "$ref": "#/definitions/code" } }, "additionalProperties": false }, "DataRequirement": { "description": "Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "type": { "description": "The type of the required data, specified as the type name of a resource. For profiles, this value is set to the type of the base resource of the profile.", "$ref": "#/definitions/code" }, "profile": { "description": "The profile of the required data, specified as the uri of the profile definition.", "items": { "$ref": "#/definitions/canonical" }, "type": "array" }, "subjectCodeableConcept": { "description": "The intended subjects of the data requirement. If this element is not provided, a Patient subject is assumed.", "$ref": "#/definitions/CodeableConcept" }, "subjectReference": { "description": "The intended subjects of the data requirement. If this element is not provided, a Patient subject is assumed.", "$ref": "#/definitions/Reference" }, "mustSupport": { "description": "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. \n\nThe 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).", "items": { "$ref": "#/definitions/string" }, "type": "array" }, "codeFilter": { "description": "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.", "items": { "$ref": "#/definitions/DataRequirement_CodeFilter" }, "type": "array" }, "dateFilter": { "description": "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.", "items": { "$ref": "#/definitions/DataRequirement_DateFilter" }, "type": "array" }, "limit": { "description": "Specifies a maximum number of results that are required (uses the _count search parameter).", "$ref": "#/definitions/positiveInt" }, "sort": { "description": "Specifies the order of the results to be returned.", "items": { "$ref": "#/definitions/DataRequirement_Sort" }, "type": "array" } }, "additionalProperties": false }, "DataRequirement_CodeFilter": { "description": "Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "path": { "description": "The code-valued attribute of the filter. The specified path SHALL be a FHIRPath resolveable on the specified type of the DataRequirement, and SHALL consist only of identifiers, constant indexers, and .resolve(). The path is allowed to contain qualifiers (.) to traverse sub-elements, as well as indexers ([x]) to traverse multiple-cardinality sub-elements (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details). Note that the index must be an integer constant. The path must resolve to an element of type code, Coding, or CodeableConcept.", "$ref": "#/definitions/string" }, "searchParam": { "description": "A token parameter that refers to a search parameter defined on the specified type of the DataRequirement, and which searches on elements of type code, Coding, or CodeableConcept.", "$ref": "#/definitions/string" }, "valueSet": { "description": "The valueset for the code filter. The valueSet and code elements are additive. If valueSet is specified, the filter will return only those data items for which the value of the code-valued element specified in the path is a member of the specified valueset.", "$ref": "#/definitions/canonical" }, "code": { "description": "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.", "items": { "$ref": "#/definitions/Coding" }, "type": "array" } }, "additionalProperties": false }, "DataRequirement_DateFilter": { "description": "Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "path": { "description": "The date-valued attribute of the filter. The specified path SHALL be a FHIRPath resolveable on the specified type of the DataRequirement, and SHALL consist only of identifiers, constant indexers, and .resolve(). The path is allowed to contain qualifiers (.) to traverse sub-elements, as well as indexers ([x]) to traverse multiple-cardinality sub-elements (see the [Simple FHIRPath Profile](fhirpath.html#simple) for full details). Note that the index must be an integer constant. The path must resolve to an element of type date, dateTime, Period, Schedule, or Timing.", "$ref": "#/definitions/string" }, "searchParam": { "description": "A date parameter that refers to a search parameter defined on the specified type of the DataRequirement, and which searches on elements of type date, dateTime, Period, Schedule, or Timing.", "$ref": "#/definitions/string" }, "valueDateTime": { "description": "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.", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$", "type": "string" }, "valuePeriod": { "description": "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.", "$ref": "#/definitions/Period" }, "valueDuration": { "description": "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.", "$ref": "#/definitions/Duration" } }, "additionalProperties": false }, "DataRequirement_Sort": { "description": "Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "path": { "description": "The attribute of the sort. The specified path must be resolvable from the type of the required data. The path is allowed to contain qualifiers (.) to traverse sub-elements, as well as indexers ([x]) to traverse multiple-cardinality sub-elements. Note that the index must be an integer constant.", "$ref": "#/definitions/string" }, "direction": { "description": "The direction of the sort, ascending or descending.", "enum": ["ascending", "descending"] } }, "additionalProperties": false }, "Device": { "description": "A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device.", "properties": { "resourceType": { "description": "This is a Device resource", "const": "Device" }, "id": { "description": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.", "$ref": "#/definitions/id" }, "meta": { "description": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.", "$ref": "#/definitions/Meta" }, "implicitRules": { "description": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content. Often, this is a reference to an implementation guide that defines the special rules along with other profiles etc.", "$ref": "#/definitions/uri" }, "language": { "description": "The base language in which the resource is written.", "$ref": "#/definitions/code" }, "text": { "description": "A human-readable narrative that contains a summary of the resource and can be used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it \"clinically safe\" for a human to just read the narrative. Resource definitions may define what content should be represented in the narrative to ensure clinical safety.", "$ref": "#/definitions/Narrative" }, "contained": { "description": "These resources do not have an independent existence apart from the resource that contains them - they cannot be identified independently, and nor can they have their own independent transaction scope.", "items": { "$ref": "#/definitions/ResourceList" }, "type": "array" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the resource. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "May be used to represent additional information that is not part of the basic definition of the resource and that modifies the understanding of the element that contains it and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "identifier": { "description": "Unique instance identifiers assigned to a device by manufacturers other organizations or owners.", "items": { "$ref": "#/definitions/Identifier" }, "type": "array" }, "definition": { "description": "The reference to the definition for the device.", "$ref": "#/definitions/Reference" }, "udiCarrier": { "description": "Unique device identifier (UDI) assigned to device label or package. Note that the Device may include multiple udiCarriers as it either may include just the udiCarrier for the jurisdiction it is sold, or for multiple jurisdictions it could have been sold.", "items": { "$ref": "#/definitions/Device_UdiCarrier" }, "type": "array" }, "status": { "description": "Status of the Device availability.", "enum": ["active", "inactive", "entered-in-error", "unknown"] }, "statusReason": { "description": "Reason for the dtatus of the Device availability.", "items": { "$ref": "#/definitions/CodeableConcept" }, "type": "array" }, "distinctIdentifier": { "description": "The distinct identification string as required by regulation for a human cell, tissue, or cellular and tissue-based product.", "$ref": "#/definitions/string" }, "manufacturer": { "description": "A name of the manufacturer.", "$ref": "#/definitions/string" }, "manufactureDate": { "description": "The date and time when the device was manufactured.", "$ref": "#/definitions/dateTime" }, "expirationDate": { "description": "The date and time beyond which this device is no longer valid or should not be used (if applicable).", "$ref": "#/definitions/dateTime" }, "lotNumber": { "description": "Lot number assigned by the manufacturer.", "$ref": "#/definitions/string" }, "serialNumber": { "description": "The serial number assigned by the organization when the device was manufactured.", "$ref": "#/definitions/string" }, "deviceName": { "description": "This represents the manufacturer's name of the device as provided by the device, from a UDI label, or by a person describing the Device. This typically would be used when a person provides the name(s) or when the device represents one of the names available from DeviceDefinition.", "items": { "$ref": "#/definitions/Device_DeviceName" }, "type": "array" }, "modelNumber": { "description": "The model number for the device.", "$ref": "#/definitions/string" }, "partNumber": { "description": "The part number of the device.", "$ref": "#/definitions/string" }, "type": { "description": "The kind or type of device.", "$ref": "#/definitions/CodeableConcept" }, "specialization": { "description": "The capabilities supported on a device, the standards to which the device conforms for a particular purpose, and used for the communication.", "items": { "$ref": "#/definitions/Device_Specialization" }, "type": "array" }, "version": { "description": "The actual design of the device or software version running on the device.", "items": { "$ref": "#/definitions/Device_Version" }, "type": "array" }, "property": { "description": "The actual configuration settings of a device as it actually operates, e.g., regulation status, time properties.", "items": { "$ref": "#/definitions/Device_Property" }, "type": "array" }, "patient": { "description": "Patient information, If the device is affixed to a person.", "$ref": "#/definitions/Reference" }, "owner": { "description": "An organization that is responsible for the provision and ongoing maintenance of the device.", "$ref": "#/definitions/Reference" }, "contact": { "description": "Contact details for an organization or a particular human that is responsible for the device.", "items": { "$ref": "#/definitions/ContactPoint" }, "type": "array" }, "location": { "description": "The place where the device can be found.", "$ref": "#/definitions/Reference" }, "url": { "description": "A network address on which the device may be contacted directly.", "$ref": "#/definitions/uri" }, "note": { "description": "Descriptive information, usage information or implantation information that is not captured in an existing element.", "items": { "$ref": "#/definitions/Annotation" }, "type": "array" }, "safety": { "description": "Provides additional safety characteristics about a medical device. For example devices containing latex.", "items": { "$ref": "#/definitions/CodeableConcept" }, "type": "array" }, "parent": { "description": "The parent device.", "$ref": "#/definitions/Reference" } }, "additionalProperties": false, "required": ["resourceType"] }, "Device_DeviceName": { "description": "A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "name": { "description": "The name of the device.", "$ref": "#/definitions/string" }, "type": { "description": "The type of deviceName.\nUDILabelName | UserFriendlyName | PatientReportedName | ManufactureDeviceName | ModelName.", "enum": [ "udi-label-name", "user-friendly-name", "patient-reported-name", "manufacturer-name", "model-name", "other" ] } }, "additionalProperties": false }, "Device_Property": { "description": "A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "type": { "description": "Code that specifies the property DeviceDefinitionPropetyCode (Extensible).", "$ref": "#/definitions/CodeableConcept" }, "valueQuantity": { "description": "Property value as a quantity.", "items": { "$ref": "#/definitions/Quantity" }, "type": "array" }, "valueCode": { "description": "Property value as a code, e.g., NTP4 (synced to NTP).", "items": { "$ref": "#/definitions/CodeableConcept" }, "type": "array" } }, "additionalProperties": false, "required": ["type"] }, "Device_Specialization": { "description": "A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "systemType": { "description": "The standard that is used to operate and communicate.", "$ref": "#/definitions/CodeableConcept" }, "version": { "description": "The version of the standard that is used to operate and communicate.", "$ref": "#/definitions/string" } }, "additionalProperties": false, "required": ["systemType"] }, "Device_UdiCarrier": { "description": "A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "deviceIdentifier": { "description": "The device identifier (DI) is a mandatory, fixed portion of a UDI that identifies the labeler and the specific version or model of a device.", "$ref": "#/definitions/string" }, "issuer": { "description": "Organization that is charged with issuing UDIs for devices. For example, the US FDA issuers include :\n1) GS1: \nhttp://hl7.org/fhir/NamingSystem/gs1-di, \n2) HIBCC:\nhttp://hl7.org/fhir/NamingSystem/hibcc-dI, \n3) ICCBBA for blood containers:\nhttp://hl7.org/fhir/NamingSystem/iccbba-blood-di, \n4) ICCBA for other devices:\nhttp://hl7.org/fhir/NamingSystem/iccbba-other-di.", "$ref": "#/definitions/uri" }, "jurisdiction": { "description": "The identity of the authoritative source for UDI generation within a jurisdiction. All UDIs are globally unique within a single namespace with the appropriate repository uri as the system. For example, UDIs of devices managed in the U.S. by the FDA, the value is http://hl7.org/fhir/NamingSystem/fda-udi.", "$ref": "#/definitions/uri" }, "carrierAIDC": { "description": "The full UDI carrier of the Automatic Identification and Data Capture (AIDC) technology representation of the barcode string as printed on the packaging of the device - e.g., a barcode or RFID. Because of limitations on character sets in XML and the need to round-trip JSON data through XML, AIDC Formats *SHALL* be base64 encoded.", "$ref": "#/definitions/base64Binary" }, "carrierHRF": { "description": "The full UDI carrier as the human readable form (HRF) representation of the barcode string as printed on the packaging of the device.", "$ref": "#/definitions/string" }, "entryType": { "description": "A coded entry to indicate how the data was entered.", "enum": ["barcode", "rfid", "manual", "card", "self-reported", "unknown"] } }, "additionalProperties": false }, "Device_Version": { "description": "A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "type": { "description": "The type of the device version.", "$ref": "#/definitions/CodeableConcept" }, "component": { "description": "A single component of the device version.", "$ref": "#/definitions/Identifier" }, "value": { "description": "The version text.", "$ref": "#/definitions/string" } }, "additionalProperties": false }, "Distance": { "description": "A length - a value with a unit that is a physical distance.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "value": { "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.", "$ref": "#/definitions/decimal" }, "comparator": { "description": "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.", "enum": ["<", "<=", ">=", ">"] }, "unit": { "description": "A human-readable form of the unit.", "$ref": "#/definitions/string" }, "system": { "description": "The identification of the system that provides the coded form of the unit.", "$ref": "#/definitions/uri" }, "code": { "description": "A computer processable form of the unit in some unit representation system.", "$ref": "#/definitions/code" } }, "additionalProperties": false }, "Dosage": { "description": "Indicates how the medication is/was taken or should be taken by the patient.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "sequence": { "description": "Indicates the order in which the dosage instructions should be applied or interpreted.", "$ref": "#/definitions/integer" }, "text": { "description": "Free text dosage instructions e.g. SIG.", "$ref": "#/definitions/string" }, "additionalInstruction": { "description": "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\").", "items": { "$ref": "#/definitions/CodeableConcept" }, "type": "array" }, "patientInstruction": { "description": "Instructions in terms that are understood by the patient or consumer.", "$ref": "#/definitions/string" }, "timing": { "description": "When medication should be administered.", "$ref": "#/definitions/Timing" }, "asNeededBoolean": { "description": "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).", "pattern": "^true|false$", "type": "boolean" }, "asNeededCodeableConcept": { "description": "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).", "$ref": "#/definitions/CodeableConcept" }, "site": { "description": "Body site to administer to.", "$ref": "#/definitions/CodeableConcept" }, "route": { "description": "How drug should enter body.", "$ref": "#/definitions/CodeableConcept" }, "method": { "description": "Technique for administering medication.", "$ref": "#/definitions/CodeableConcept" }, "doseAndRate": { "description": "The amount of medication administered.", "items": { "$ref": "#/definitions/Dosage_DoseAndRate" }, "type": "array" }, "maxDosePerPeriod": { "description": "Upper limit on medication per unit of time.", "$ref": "#/definitions/Ratio" }, "maxDosePerAdministration": { "description": "Upper limit on medication per administration.", "$ref": "#/definitions/Quantity" }, "maxDosePerLifetime": { "description": "Upper limit on medication per lifetime of the patient.", "$ref": "#/definitions/Quantity" } }, "additionalProperties": false }, "Dosage_DoseAndRate": { "description": "Indicates how the medication is/was taken or should be taken by the patient.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "type": { "description": "The kind of dose or rate specified, for example, ordered or calculated.", "$ref": "#/definitions/CodeableConcept" }, "doseRange": { "description": "Amount of medication per dose.", "$ref": "#/definitions/Range" }, "doseQuantity": { "description": "Amount of medication per dose.", "$ref": "#/definitions/Quantity" }, "rateRatio": { "description": "Amount of medication per unit of time.", "$ref": "#/definitions/Ratio" }, "rateRange": { "description": "Amount of medication per unit of time.", "$ref": "#/definitions/Range" }, "rateQuantity": { "description": "Amount of medication per unit of time.", "$ref": "#/definitions/Quantity" } }, "additionalProperties": false }, "Duration": { "description": "A length of time.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "value": { "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.", "$ref": "#/definitions/decimal" }, "comparator": { "description": "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.", "enum": ["<", "<=", ">=", ">"] }, "unit": { "description": "A human-readable form of the unit.", "$ref": "#/definitions/string" }, "system": { "description": "The identification of the system that provides the coded form of the unit.", "$ref": "#/definitions/uri" }, "code": { "description": "A computer processable form of the unit in some unit representation system.", "$ref": "#/definitions/code" } }, "additionalProperties": false }, "Element": { "description": "Base definition for all elements in a resource.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" } }, "additionalProperties": false }, "Expression": { "description": "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.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "description": { "description": "A brief, natural language description of the condition that effectively communicates the intended semantics.", "$ref": "#/definitions/string" }, "name": { "description": "A short name assigned to the expression to allow for multiple reuse of the expression in the context where it is defined.", "$ref": "#/definitions/id" }, "language": { "description": "The media type of the language for the expression.", "enum": ["text/cql", "text/fhirpath", "application/x-fhir-query"] }, "expression": { "description": "An expression in the specified language that returns a value.", "$ref": "#/definitions/string" }, "reference": { "description": "A URI that defines where the expression is found.", "$ref": "#/definitions/uri" } }, "additionalProperties": false }, "Extension": { "description": "Optional Extension Element - found in all resources.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "url": { "description": "Source of the definition for the extension code - a logical name or a URL.", "$ref": "#/definitions/uri" }, "valueBase64Binary": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^(\\s*([0-9a-zA-Z\\+/=]){4}\\s*)+$", "type": "string" }, "valueBoolean": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^true|false$", "type": "boolean" }, "valueCanonical": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^\\S*$", "type": "string" }, "valueCode": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^[^\\s]+(\\s[^\\s]+)*$", "type": "string" }, "valueDate": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1]))?)?$", "type": "string" }, "valueDateTime": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$", "type": "string" }, "valueDecimal": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$", "type": "number" }, "valueId": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^[A-Za-z0-9\\-\\.]{1,64}$", "type": "string" }, "valueInstant": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))$", "type": "string" }, "valueInteger": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^-?([0]|([1-9][0-9]*))$", "type": "number" }, "valueMarkdown": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^[ \\r\\n\\t\\S]+$", "type": "string" }, "valueOid": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^urn:oid:[0-2](\\.(0|[1-9][0-9]*))+$", "type": "string" }, "valuePositiveInt": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^[1-9][0-9]*$", "type": "number" }, "valueString": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^[ \\r\\n\\t\\S]+$", "type": "string" }, "valueTime": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?$", "type": "string" }, "valueUnsignedInt": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^[0]|([1-9][0-9]*)$", "type": "number" }, "valueUri": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^\\S*$", "type": "string" }, "valueUrl": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^\\S*$", "type": "string" }, "valueUuid": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "pattern": "^urn:uuid:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", "type": "string" }, "valueAddress": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Address" }, "valueAge": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Age" }, "valueAnnotation": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Annotation" }, "valueAttachment": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Attachment" }, "valueCodeableConcept": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/CodeableConcept" }, "valueCoding": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Coding" }, "valueContactPoint": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/ContactPoint" }, "valueCount": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Count" }, "valueDistance": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Distance" }, "valueDuration": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Duration" }, "valueHumanName": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/HumanName" }, "valueIdentifier": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Identifier" }, "valueMoney": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Money" }, "valuePeriod": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Period" }, "valueQuantity": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Quantity" }, "valueRange": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Range" }, "valueRatio": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Ratio" }, "valueReference": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Reference" }, "valueSampledData": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/SampledData" }, "valueSignature": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Signature" }, "valueTiming": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Timing" }, "valueContactDetail": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/ContactDetail" }, "valueContributor": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Contributor" }, "valueDataRequirement": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/DataRequirement" }, "valueExpression": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Expression" }, "valueParameterDefinition": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/ParameterDefinition" }, "valueRelatedArtifact": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/RelatedArtifact" }, "valueTriggerDefinition": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/TriggerDefinition" }, "valueUsageContext": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/UsageContext" }, "valueDosage": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Dosage" }, "valueMeta": { "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).", "$ref": "#/definitions/Meta" } }, "additionalProperties": false }, "HumanName": { "description": "A human's name with the ability to identify parts and usage.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "use": { "description": "Identifies the purpose for this name.", "enum": ["usual", "official", "temp", "nickname", "anonymous", "old", "maiden"] }, "text": { "description": "Specifies the entire name as it should be displayed e.g. on an application UI. This may be provided instead of or as well as the specific parts.", "$ref": "#/definitions/string" }, "family": { "description": "The part of a name that links to the genealogy. In some cultures (e.g. Eritrea) the family name of a son is the first name of his father.", "$ref": "#/definitions/string" }, "given": { "description": "Given name.", "items": { "$ref": "#/definitions/string" }, "type": "array" }, "prefix": { "description": "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.", "items": { "$ref": "#/definitions/string" }, "type": "array" }, "suffix": { "description": "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.", "items": { "$ref": "#/definitions/string" }, "type": "array" }, "period": { "description": "Indicates the period of time when this name was valid for the named person.", "$ref": "#/definitions/Period" } }, "additionalProperties": false }, "Identifier": { "description": "An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "use": { "description": "The purpose of this identifier.", "enum": ["usual", "official", "temp", "secondary", "old"] }, "type": { "description": "A coded type for the identifier that can be used to determine which identifier to use for a specific purpose.", "$ref": "#/definitions/CodeableConcept" }, "system": { "description": "Establishes the namespace for the value - that is, a URL that describes a set values that are unique.", "$ref": "#/definitions/uri" }, "value": { "description": "The portion of the identifier typically relevant to the user and which is unique within the context of the system.", "$ref": "#/definitions/string" }, "period": { "description": "Time period during which identifier is/was valid for use.", "$ref": "#/definitions/Period" }, "assigner": { "description": "Organization that issued/manages the identifier.", "$ref": "#/definitions/Reference" } }, "additionalProperties": false }, "Meta": { "description": "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.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "versionId": { "description": "The version specific identifier, as it appears in the version portion of the URL. This value changes when the resource is created, updated, or deleted.", "$ref": "#/definitions/id" }, "lastUpdated": { "description": "When the resource last changed - e.g. when the version changed.", "$ref": "#/definitions/instant" }, "source": { "description": "A uri that identifies the source system of the resource. This provides a minimal amount of [[[Provenance]]] information that can be used to track or differentiate the source of information in the resource. The source may identify another FHIR server, document, message, database, etc.", "$ref": "#/definitions/uri" }, "profile": { "description": "A list of profiles (references to [[[StructureDefinition]]] resources) that this resource claims to conform to. The URL is a reference to [[[StructureDefinition.url]]].", "items": { "$ref": "#/definitions/canonical" }, "type": "array" }, "security": { "description": "Security labels applied to this resource. These tags connect specific resources to the overall security policy and infrastructure.", "items": { "$ref": "#/definitions/Coding" }, "type": "array" }, "tag": { "description": "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.", "items": { "$ref": "#/definitions/Coding" }, "type": "array" } }, "additionalProperties": false }, "Money": { "description": "An amount of economic utility in some recognized currency.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "value": { "description": "Numerical value (with implicit precision).", "$ref": "#/definitions/decimal" }, "currency": { "description": "ISO 4217 Currency Code.", "$ref": "#/definitions/code" } }, "additionalProperties": false }, "Narrative": { "description": "A human-readable summary of the resource conveying the essential clinical and business information for the resource.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "status": { "description": "The status of the narrative - whether it's entirely generated (from just the defined data or the extensions too), or whether a human authored it and it may contain additional data.", "enum": ["generated", "extensions", "additional", "empty"] }, "div": { "description": "The actual narrative content, a stripped down version of XHTML.", "$ref": "#/definitions/xhtml" } }, "additionalProperties": false, "required": ["div"] }, "Observation": { "description": "Measurements and simple assertions made about a patient, device or other subject.", "properties": { "resourceType": { "description": "This is a Observation resource", "const": "Observation" }, "id": { "description": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.", "$ref": "#/definitions/id" }, "meta": { "description": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.", "$ref": "#/definitions/Meta" }, "implicitRules": { "description": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content. Often, this is a reference to an implementation guide that defines the special rules along with other profiles etc.", "$ref": "#/definitions/uri" }, "language": { "description": "The base language in which the resource is written.", "$ref": "#/definitions/code" }, "text": { "description": "A human-readable narrative that contains a summary of the resource and can be used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it \"clinically safe\" for a human to just read the narrative. Resource definitions may define what content should be represented in the narrative to ensure clinical safety.", "$ref": "#/definitions/Narrative" }, "contained": { "description": "These resources do not have an independent existence apart from the resource that contains them - they cannot be identified independently, and nor can they have their own independent transaction scope.", "items": { "$ref": "#/definitions/ResourceList" }, "type": "array" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the resource. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "May be used to represent additional information that is not part of the basic definition of the resource and that modifies the understanding of the element that contains it and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "identifier": { "description": "A unique identifier assigned to this observation.", "items": { "$ref": "#/definitions/Identifier" }, "type": "array" }, "basedOn": { "description": "A plan, proposal or order that is fulfilled in whole or in part by this event. For example, a MedicationRequest may require a patient to have laboratory test performed before it is dispensed.", "items": { "$ref": "#/definitions/Reference" }, "type": "array" }, "partOf": { "description": "A larger event of which this particular Observation is a component or step. For example, an observation as part of a procedure.", "items": { "$ref": "#/definitions/Reference" }, "type": "array" }, "status": { "description": "The status of the result value.", "enum": [ "registered", "preliminary", "final", "amended", "corrected", "cancelled", "entered-in-error", "unknown" ] }, "category": { "description": "A code that classifies the general type of observation being made.", "items": { "$ref": "#/definitions/CodeableConcept" }, "type": "array" }, "code": { "description": "Describes what was observed. Sometimes this is called the observation \"name\".", "$ref": "#/definitions/CodeableConcept" }, "subject": { "description": "The patient, or group of patients, location, or device this observation is about and into whose record the observation is placed. If the actual focus of the observation is different from the subject (or a sample of, part, or region of the subject), the `focus` element or the `code` itself specifies the actual focus of the observation.", "$ref": "#/definitions/Reference" }, "focus": { "description": "The actual focus of an observation when it is not the patient of record representing something or someone associated with the patient such as a spouse, parent, fetus, or donor. For example, fetus observations in a mother's record. The focus of an observation could also be an existing condition, an intervention, the subject's diet, another observation of the subject, or a body structure such as tumor or implanted device. An example use case would be using the Observation resource to capture whether the mother is trained to change her child's tracheostomy tube. In this example, the child is the patient of record and the mother is the focus.", "items": { "$ref": "#/definitions/Reference" }, "type": "array" }, "encounter": { "description": "The healthcare event (e.g. a patient and healthcare provider interaction) during which this observation is made.", "$ref": "#/definitions/Reference" }, "effectiveDateTime": { "description": "The time or time-period the observed value is asserted as being true. For biological subjects - e.g. human patients - this is usually called the \"physiologically relevant time\". This is usually either the time of the procedure or of specimen collection, but very often the source of the date/time is not known, only the date/time itself.", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$", "type": "string" }, "effectivePeriod": { "description": "The time or time-period the observed value is asserted as being true. For biological subjects - e.g. human patients - this is usually called the \"physiologically relevant time\". This is usually either the time of the procedure or of specimen collection, but very often the source of the date/time is not known, only the date/time itself.", "$ref": "#/definitions/Period" }, "effectiveTiming": { "description": "The time or time-period the observed value is asserted as being true. For biological subjects - e.g. human patients - this is usually called the \"physiologically relevant time\". This is usually either the time of the procedure or of specimen collection, but very often the source of the date/time is not known, only the date/time itself.", "$ref": "#/definitions/Timing" }, "effectiveInstant": { "description": "The time or time-period the observed value is asserted as being true. For biological subjects - e.g. human patients - this is usually called the \"physiologically relevant time\". This is usually either the time of the procedure or of specimen collection, but very often the source of the date/time is not known, only the date/time itself.", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))$", "type": "string" }, "issued": { "description": "The date and time this version of the observation was made available to providers, typically after the results have been reviewed and verified.", "$ref": "#/definitions/instant" }, "performer": { "description": "Who was responsible for asserting the observed value as \"true\".", "items": { "$ref": "#/definitions/Reference" }, "type": "array" }, "valueQuantity": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "$ref": "#/definitions/Quantity" }, "valueCodeableConcept": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "$ref": "#/definitions/CodeableConcept" }, "valueString": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "pattern": "^[ \\r\\n\\t\\S]+$", "type": "string" }, "valueBoolean": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "pattern": "^true|false$", "type": "boolean" }, "valueInteger": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "pattern": "^-?([0]|([1-9][0-9]*))$", "type": "number" }, "valueRange": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "$ref": "#/definitions/Range" }, "valueRatio": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "$ref": "#/definitions/Ratio" }, "valueSampledData": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "$ref": "#/definitions/SampledData" }, "valueTime": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "pattern": "^([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?$", "type": "string" }, "valueDateTime": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$", "type": "string" }, "valuePeriod": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "$ref": "#/definitions/Period" }, "dataAbsentReason": { "description": "Provides a reason why the expected value in the element Observation.value[x] is missing.", "$ref": "#/definitions/CodeableConcept" }, "interpretation": { "description": "A categorical assessment of an observation value. For example, high, low, normal.", "items": { "$ref": "#/definitions/CodeableConcept" }, "type": "array" }, "note": { "description": "Comments about the observation or the results.", "items": { "$ref": "#/definitions/Annotation" }, "type": "array" }, "bodySite": { "description": "Indicates the site on the subject's body where the observation was made (i.e. the target site).", "$ref": "#/definitions/CodeableConcept" }, "method": { "description": "Indicates the mechanism used to perform the observation.", "$ref": "#/definitions/CodeableConcept" }, "specimen": { "description": "The specimen that was used when this observation was made.", "$ref": "#/definitions/Reference" }, "device": { "description": "The device used to generate the observation data.", "$ref": "#/definitions/Reference" }, "referenceRange": { "description": "Guidance on how to interpret the value by comparison to a normal or recommended range. Multiple reference ranges are interpreted as an \"OR\". In other words, to represent two distinct target populations, two `referenceRange` elements would be used.", "items": { "$ref": "#/definitions/Observation_ReferenceRange" }, "type": "array" }, "hasMember": { "description": "This observation is a group observation (e.g. a battery, a panel of tests, a set of vital sign measurements) that includes the target as a member of the group.", "items": { "$ref": "#/definitions/Reference" }, "type": "array" }, "derivedFrom": { "description": "The target resource that represents a measurement from which this observation value is derived. For example, a calculated anion gap or a fetal measurement based on an ultrasound image.", "items": { "$ref": "#/definitions/Reference" }, "type": "array" }, "component": { "description": "Some observations have multiple component observations. These component observations are expressed as separate code value pairs that share the same attributes. Examples include systolic and diastolic component observations for blood pressure measurement and multiple component observations for genetics observations.", "items": { "$ref": "#/definitions/Observation_Component" }, "type": "array" } }, "additionalProperties": false, "required": ["code", "resourceType"] }, "Observation_Component": { "description": "Measurements and simple assertions made about a patient, device or other subject.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "code": { "description": "Describes what was observed. Sometimes this is called the observation \"code\".", "$ref": "#/definitions/CodeableConcept" }, "valueQuantity": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "$ref": "#/definitions/Quantity" }, "valueCodeableConcept": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "$ref": "#/definitions/CodeableConcept" }, "valueString": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "pattern": "^[ \\r\\n\\t\\S]+$", "type": "string" }, "valueBoolean": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "pattern": "^true|false$", "type": "boolean" }, "valueInteger": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "pattern": "^-?([0]|([1-9][0-9]*))$", "type": "number" }, "valueRange": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "$ref": "#/definitions/Range" }, "valueRatio": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "$ref": "#/definitions/Ratio" }, "valueSampledData": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "$ref": "#/definitions/SampledData" }, "valueTime": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "pattern": "^([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?$", "type": "string" }, "valueDateTime": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$", "type": "string" }, "valuePeriod": { "description": "The information determined as a result of making the observation, if the information has a simple value.", "$ref": "#/definitions/Period" }, "dataAbsentReason": { "description": "Provides a reason why the expected value in the element Observation.component.value[x] is missing.", "$ref": "#/definitions/CodeableConcept" }, "interpretation": { "description": "A categorical assessment of an observation value. For example, high, low, normal.", "items": { "$ref": "#/definitions/CodeableConcept" }, "type": "array" }, "referenceRange": { "description": "Guidance on how to interpret the value by comparison to a normal or recommended range.", "items": { "$ref": "#/definitions/Observation_ReferenceRange" }, "type": "array" } }, "additionalProperties": false, "required": ["code"] }, "Observation_ReferenceRange": { "description": "Measurements and simple assertions made about a patient, device or other subject.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "low": { "description": "The value of the low bound of the reference range. The low bound of the reference range endpoint is inclusive of the value (e.g. reference range is >=5 - <=9). If the low bound is omitted, it is assumed to be meaningless (e.g. reference range is <=2.3).", "$ref": "#/definitions/Quantity" }, "high": { "description": "The value of the high bound of the reference range. The high bound of the reference range endpoint is inclusive of the value (e.g. reference range is >=5 - <=9). If the high bound is omitted, it is assumed to be meaningless (e.g. reference range is >= 2.3).", "$ref": "#/definitions/Quantity" }, "type": { "description": "Codes to indicate the what part of the targeted reference population it applies to. For example, the normal or therapeutic range.", "$ref": "#/definitions/CodeableConcept" }, "appliesTo": { "description": "Codes to indicate the target population this reference range applies to. For example, a reference range may be based on the normal population or a particular sex or race. Multiple `appliesTo` are interpreted as an \"AND\" of the target populations. For example, to represent a target population of African American females, both a code of female and a code for African American would be used.", "items": { "$ref": "#/definitions/CodeableConcept" }, "type": "array" }, "age": { "description": "The age at which this reference range is applicable. This is a neonatal age (e.g. number of weeks at term) if the meaning says so.", "$ref": "#/definitions/Range" }, "text": { "description": "Text based reference range in an observation which may be used when a quantitative range is not appropriate for an observation. An example would be a reference value of \"Negative\" or a list or table of \"normals\".", "$ref": "#/definitions/string" } }, "additionalProperties": false }, "Organization": { "description": "A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action. Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc.", "properties": { "resourceType": { "description": "This is a Organization resource", "const": "Organization" }, "id": { "description": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.", "$ref": "#/definitions/id" }, "meta": { "description": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.", "$ref": "#/definitions/Meta" }, "implicitRules": { "description": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content. Often, this is a reference to an implementation guide that defines the special rules along with other profiles etc.", "$ref": "#/definitions/uri" }, "language": { "description": "The base language in which the resource is written.", "$ref": "#/definitions/code" }, "text": { "description": "A human-readable narrative that contains a summary of the resource and can be used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it \"clinically safe\" for a human to just read the narrative. Resource definitions may define what content should be represented in the narrative to ensure clinical safety.", "$ref": "#/definitions/Narrative" }, "contained": { "description": "These resources do not have an independent existence apart from the resource that contains them - they cannot be identified independently, and nor can they have their own independent transaction scope.", "items": { "$ref": "#/definitions/ResourceList" }, "type": "array" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the resource. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "May be used to represent additional information that is not part of the basic definition of the resource and that modifies the understanding of the element that contains it and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "identifier": { "description": "Identifier for the organization that is used to identify the organization across multiple disparate systems.", "items": { "$ref": "#/definitions/Identifier" }, "type": "array" }, "active": { "description": "Whether the organization's record is still in active use.", "$ref": "#/definitions/boolean" }, "type": { "description": "The kind(s) of organization that this is.", "items": { "$ref": "#/definitions/CodeableConcept" }, "type": "array" }, "name": { "description": "A name associated with the organization.", "$ref": "#/definitions/string" }, "alias": { "description": "A list of alternate names that the organization is known as, or was known as in the past.", "items": { "$ref": "#/definitions/string" }, "type": "array" }, "telecom": { "description": "A contact detail for the organization.", "items": { "$ref": "#/definitions/ContactPoint" }, "type": "array" }, "address": { "description": "An address for the organization.", "items": { "$ref": "#/definitions/Address" }, "type": "array" }, "partOf": { "description": "The organization of which this organization forms a part.", "$ref": "#/definitions/Reference" }, "contact": { "description": "Contact for the organization for a certain purpose.", "items": { "$ref": "#/definitions/Organization_Contact" }, "type": "array" }, "endpoint": { "description": "Technical endpoints providing access to services operated for the organization.", "items": { "$ref": "#/definitions/Reference" }, "type": "array" } }, "additionalProperties": false, "required": ["resourceType"] }, "Organization_Contact": { "description": "A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action. Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "purpose": { "description": "Indicates a purpose for which the contact can be reached.", "$ref": "#/definitions/CodeableConcept" }, "name": { "description": "A name associated with the contact.", "$ref": "#/definitions/HumanName" }, "telecom": { "description": "A contact detail (e.g. a telephone number or an email address) by which the party may be contacted.", "items": { "$ref": "#/definitions/ContactPoint" }, "type": "array" }, "address": { "description": "Visiting or postal addresses for the contact.", "$ref": "#/definitions/Address" } }, "additionalProperties": false }, "ParameterDefinition": { "description": "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.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "name": { "description": "The name of the parameter used to allow access to the value of the parameter in evaluation contexts.", "$ref": "#/definitions/code" }, "use": { "description": "Whether the parameter is input or output for the module.", "$ref": "#/definitions/code" }, "min": { "description": "The minimum number of times this parameter SHALL appear in the request or response.", "$ref": "#/definitions/integer" }, "max": { "description": "The maximum number of times this element is permitted to appear in the request or response.", "$ref": "#/definitions/string" }, "documentation": { "description": "A brief discussion of what the parameter is for and how it is used by the module.", "$ref": "#/definitions/string" }, "type": { "description": "The type of the parameter.", "$ref": "#/definitions/code" }, "profile": { "description": "If specified, this indicates a profile that the input data must conform to, or that the output data will conform to.", "$ref": "#/definitions/canonical" } }, "additionalProperties": false }, "Patient": { "description": "Demographics and other administrative information about an individual or animal receiving care or other health-related services.", "properties": { "resourceType": { "description": "This is a Patient resource", "const": "Patient" }, "id": { "description": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.", "$ref": "#/definitions/id" }, "meta": { "description": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.", "$ref": "#/definitions/Meta" }, "implicitRules": { "description": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content. Often, this is a reference to an implementation guide that defines the special rules along with other profiles etc.", "$ref": "#/definitions/uri" }, "language": { "description": "The base language in which the resource is written.", "$ref": "#/definitions/code" }, "text": { "description": "A human-readable narrative that contains a summary of the resource and can be used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it \"clinically safe\" for a human to just read the narrative. Resource definitions may define what content should be represented in the narrative to ensure clinical safety.", "$ref": "#/definitions/Narrative" }, "contained": { "description": "These resources do not have an independent existence apart from the resource that contains them - they cannot be identified independently, and nor can they have their own independent transaction scope.", "items": { "$ref": "#/definitions/ResourceList" }, "type": "array" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the resource. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "May be used to represent additional information that is not part of the basic definition of the resource and that modifies the understanding of the element that contains it and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "identifier": { "description": "An identifier for this patient.", "items": { "$ref": "#/definitions/Identifier" }, "type": "array" }, "active": { "description": "Whether this patient record is in active use. \nMany systems use this property to mark as non-current patients, such as those that have not been seen for a period of time based on an organization's business rules.\n\nIt is often used to filter patient lists to exclude inactive patients\n\nDeceased patients may also be marked as inactive for the same reasons, but may be active for some time after death.", "$ref": "#/definitions/boolean" }, "name": { "description": "A name associated with the individual.", "items": { "$ref": "#/definitions/HumanName" }, "type": "array" }, "telecom": { "description": "A contact detail (e.g. a telephone number or an email address) by which the individual may be contacted.", "items": { "$ref": "#/definitions/ContactPoint" }, "type": "array" }, "gender": { "description": "Administrative Gender - the gender that the patient is considered to have for administration and record keeping purposes.", "enum": ["male", "female", "other", "unknown"] }, "birthDate": { "description": "The date of birth for the individual.", "$ref": "#/definitions/date" }, "deceasedBoolean": { "description": "Indicates if the individual is deceased or not.", "pattern": "^true|false$", "type": "boolean" }, "deceasedDateTime": { "description": "Indicates if the individual is deceased or not.", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$", "type": "string" }, "address": { "description": "An address for the individual.", "items": { "$ref": "#/definitions/Address" }, "type": "array" }, "maritalStatus": { "description": "This field contains a patient's most recent marital (civil) status.", "$ref": "#/definitions/CodeableConcept" }, "multipleBirthBoolean": { "description": "Indicates whether the patient is part of a multiple (boolean) or indicates the actual birth order (integer).", "pattern": "^true|false$", "type": "boolean" }, "multipleBirthInteger": { "description": "Indicates whether the patient is part of a multiple (boolean) or indicates the actual birth order (integer).", "pattern": "^-?([0]|([1-9][0-9]*))$", "type": "number" }, "photo": { "description": "Image of the patient.", "items": { "$ref": "#/definitions/Attachment" }, "type": "array" }, "contact": { "description": "A contact party (e.g. guardian, partner, friend) for the patient.", "items": { "$ref": "#/definitions/Patient_Contact" }, "type": "array" }, "communication": { "description": "A language which may be used to communicate with the patient about his or her health.", "items": { "$ref": "#/definitions/Patient_Communication" }, "type": "array" }, "generalPractitioner": { "description": "Patient's nominated care provider.", "items": { "$ref": "#/definitions/Reference" }, "type": "array" }, "managingOrganization": { "description": "Organization that is the custodian of the patient record.", "$ref": "#/definitions/Reference" }, "link": { "description": "Link to another patient resource that concerns the same actual patient.", "items": { "$ref": "#/definitions/Patient_Link" }, "type": "array" } }, "additionalProperties": false, "required": ["resourceType"] }, "Patient_Communication": { "description": "Demographics and other administrative information about an individual or animal receiving care or other health-related services.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "language": { "description": "The ISO-639-1 alpha 2 code in lower case for the language, optionally followed by a hyphen and the ISO-3166-1 alpha 2 code for the region in upper case; e.g. \"en\" for English, or \"en-US\" for American English versus \"en-EN\" for England English.", "$ref": "#/definitions/CodeableConcept" }, "preferred": { "description": "Indicates whether or not the patient prefers this language (over other languages he masters up a certain level).", "$ref": "#/definitions/boolean" } }, "additionalProperties": false, "required": ["language"] }, "Patient_Contact": { "description": "Demographics and other administrative information about an individual or animal receiving care or other health-related services.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "relationship": { "description": "The nature of the relationship between the patient and the contact person.", "items": { "$ref": "#/definitions/CodeableConcept" }, "type": "array" }, "name": { "description": "A name associated with the contact person.", "$ref": "#/definitions/HumanName" }, "telecom": { "description": "A contact detail for the person, e.g. a telephone number or an email address.", "items": { "$ref": "#/definitions/ContactPoint" }, "type": "array" }, "address": { "description": "Address for the contact person.", "$ref": "#/definitions/Address" }, "gender": { "description": "Administrative Gender - the gender that the contact person is considered to have for administration and record keeping purposes.", "enum": ["male", "female", "other", "unknown"] }, "organization": { "description": "Organization on behalf of which the contact is acting or for which the contact is working.", "$ref": "#/definitions/Reference" }, "period": { "description": "The period during which this contact person or organization is valid to be contacted relating to this patient.", "$ref": "#/definitions/Period" } }, "additionalProperties": false }, "Patient_Link": { "description": "Demographics and other administrative information about an individual or animal receiving care or other health-related services.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "other": { "description": "The other patient resource that the link refers to.", "$ref": "#/definitions/Reference" }, "type": { "description": "The type of link between this patient resource and another patient resource.", "enum": ["replaced-by", "replaces", "refer", "seealso"] } }, "additionalProperties": false, "required": ["other"] }, "Period": { "description": "A time period defined by a start and end date and optionally time.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "start": { "description": "The start of the period. The boundary is inclusive.", "$ref": "#/definitions/dateTime" }, "end": { "description": "The end of the period. If the end of the period is missing, it means no end was known or planned at the time the instance was created. The start may be in the past, and the end date in the future, which means that period is expected/planned to end at that time.", "$ref": "#/definitions/dateTime" } }, "additionalProperties": false }, "Practitioner": { "description": "A person who is directly or indirectly involved in the provisioning of healthcare.", "properties": { "resourceType": { "description": "This is a Practitioner resource", "const": "Practitioner" }, "id": { "description": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.", "$ref": "#/definitions/id" }, "meta": { "description": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.", "$ref": "#/definitions/Meta" }, "implicitRules": { "description": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content. Often, this is a reference to an implementation guide that defines the special rules along with other profiles etc.", "$ref": "#/definitions/uri" }, "language": { "description": "The base language in which the resource is written.", "$ref": "#/definitions/code" }, "text": { "description": "A human-readable narrative that contains a summary of the resource and can be used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it \"clinically safe\" for a human to just read the narrative. Resource definitions may define what content should be represented in the narrative to ensure clinical safety.", "$ref": "#/definitions/Narrative" }, "contained": { "description": "These resources do not have an independent existence apart from the resource that contains them - they cannot be identified independently, and nor can they have their own independent transaction scope.", "items": { "$ref": "#/definitions/ResourceList" }, "type": "array" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the resource. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "May be used to represent additional information that is not part of the basic definition of the resource and that modifies the understanding of the element that contains it and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "identifier": { "description": "An identifier that applies to this person in this role.", "items": { "$ref": "#/definitions/Identifier" }, "type": "array" }, "active": { "description": "Whether this practitioner's record is in active use.", "$ref": "#/definitions/boolean" }, "name": { "description": "The name(s) associated with the practitioner.", "items": { "$ref": "#/definitions/HumanName" }, "type": "array" }, "telecom": { "description": "A contact detail for the practitioner, e.g. a telephone number or an email address.", "items": { "$ref": "#/definitions/ContactPoint" }, "type": "array" }, "address": { "description": "Address(es) of the practitioner that are not role specific (typically home address). \rWork addresses are not typically entered in this property as they are usually role dependent.", "items": { "$ref": "#/definitions/Address" }, "type": "array" }, "gender": { "description": "Administrative Gender - the gender that the person is considered to have for administration and record keeping purposes.", "enum": ["male", "female", "other", "unknown"] }, "birthDate": { "description": "The date of birth for the practitioner.", "$ref": "#/definitions/date" }, "photo": { "description": "Image of the person.", "items": { "$ref": "#/definitions/Attachment" }, "type": "array" }, "qualification": { "description": "The official certifications, training, and licenses that authorize or otherwise pertain to the provision of care by the practitioner. For example, a medical license issued by a medical board authorizing the practitioner to practice medicine within a certian locality.", "items": { "$ref": "#/definitions/Practitioner_Qualification" }, "type": "array" }, "communication": { "description": "A language the practitioner can use in patient communication.", "items": { "$ref": "#/definitions/CodeableConcept" }, "type": "array" } }, "additionalProperties": false, "required": ["resourceType"] }, "Practitioner_Qualification": { "description": "A person who is directly or indirectly involved in the provisioning of healthcare.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "identifier": { "description": "An identifier that applies to this person's qualification in this role.", "items": { "$ref": "#/definitions/Identifier" }, "type": "array" }, "code": { "description": "Coded representation of the qualification.", "$ref": "#/definitions/CodeableConcept" }, "period": { "description": "Period during which the qualification is valid.", "$ref": "#/definitions/Period" }, "issuer": { "description": "Organization that regulates and issues the qualification.", "$ref": "#/definitions/Reference" } }, "additionalProperties": false, "required": ["code"] }, "Quantity": { "description": "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.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "value": { "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.", "$ref": "#/definitions/decimal" }, "comparator": { "description": "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.", "enum": ["<", "<=", ">=", ">"] }, "unit": { "description": "A human-readable form of the unit.", "$ref": "#/definitions/string" }, "system": { "description": "The identification of the system that provides the coded form of the unit.", "$ref": "#/definitions/uri" }, "code": { "description": "A computer processable form of the unit in some unit representation system.", "$ref": "#/definitions/code" } }, "additionalProperties": false }, "Range": { "description": "A set of ordered Quantities defined by a low and high limit.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "low": { "description": "The low limit. The boundary is inclusive.", "$ref": "#/definitions/Quantity" }, "high": { "description": "The high limit. The boundary is inclusive.", "$ref": "#/definitions/Quantity" } }, "additionalProperties": false }, "Ratio": { "description": "A relationship of two Quantity values - expressed as a numerator and a denominator.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "numerator": { "description": "The value of the numerator.", "$ref": "#/definitions/Quantity" }, "denominator": { "description": "The value of the denominator.", "$ref": "#/definitions/Quantity" } }, "additionalProperties": false }, "Reference": { "description": "A reference from one resource to another.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "reference": { "description": "A reference to a location at which the other resource is found. The reference may be a relative reference, in which case it is relative to the service base URL, or an absolute URL that resolves to the location where the resource is found. The reference may be version specific or not. If the reference is not to a FHIR RESTful server, then it should be assumed to be version specific. Internal fragment references (start with '#') refer to contained resources.", "$ref": "#/definitions/string" }, "type": { "description": "The expected type of the target of the reference. If both Reference.type and Reference.reference are populated and Reference.reference is a FHIR URL, both SHALL be consistent.\n\nThe type is the Canonical URL of Resource Definition that is the type this reference refers to. References are URLs that are relative to http://hl7.org/fhir/StructureDefinition/ e.g. \"Patient\" is a reference to http://hl7.org/fhir/StructureDefinition/Patient. Absolute URLs are only allowed for logical models (and can only be used in references in logical models, not resources).", "$ref": "#/definitions/uri" }, "identifier": { "description": "An identifier for the target resource. This is used when there is no way to reference the other resource directly, either because the entity it represents is not available through a FHIR server, or because there is no way for the author of the resource to convert a known identifier to an actual location. There is no requirement that a Reference.identifier point to something that is actually exposed as a FHIR instance, but it SHALL point to a business concept that would be expected to be exposed as a FHIR instance, and that instance would need to be of a FHIR resource type allowed by the reference.", "$ref": "#/definitions/Identifier" }, "display": { "description": "Plain text narrative that identifies the resource in addition to the resource reference.", "$ref": "#/definitions/string" } }, "additionalProperties": false }, "RelatedArtifact": { "description": "Related artifacts such as additional documentation, justification, or bibliographic references.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "type": { "description": "The type of relationship to the related artifact.", "enum": [ "documentation", "justification", "citation", "predecessor", "successor", "derived-from", "depends-on", "composed-of" ] }, "label": { "description": "A short label that can be used to reference the citation from elsewhere in the containing artifact, such as a footnote index.", "$ref": "#/definitions/string" }, "display": { "description": "A brief description of the document or knowledge resource being referenced, suitable for display to a consumer.", "$ref": "#/definitions/string" }, "citation": { "description": "A bibliographic citation for the related artifact. This text SHOULD be formatted according to an accepted citation format.", "$ref": "#/definitions/markdown" }, "url": { "description": "A url for the artifact that can be followed to access the actual content.", "$ref": "#/definitions/url" }, "document": { "description": "The document being referenced, represented as an attachment. This is exclusive with the resource element.", "$ref": "#/definitions/Attachment" }, "resource": { "description": "The related resource, such as a library, value set, profile, or other knowledge resource.", "$ref": "#/definitions/canonical" } }, "additionalProperties": false }, "SampledData": { "description": "A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "origin": { "description": "The base quantity that a measured value of zero represents. In addition, this provides the units of the entire measurement series.", "$ref": "#/definitions/Quantity" }, "period": { "description": "The length of time between sampling times, measured in milliseconds.", "$ref": "#/definitions/decimal" }, "factor": { "description": "A correction factor that is applied to the sampled data points before they are added to the origin.", "$ref": "#/definitions/decimal" }, "lowerLimit": { "description": "The lower limit of detection of the measured points. This is needed if any of the data points have the value \"L\" (lower than detection limit).", "$ref": "#/definitions/decimal" }, "upperLimit": { "description": "The upper limit of detection of the measured points. This is needed if any of the data points have the value \"U\" (higher than detection limit).", "$ref": "#/definitions/decimal" }, "dimensions": { "description": "The number of sample points at each time point. If this value is greater than one, then the dimensions will be interlaced - all the sample points for a point in time will be recorded at once.", "$ref": "#/definitions/positiveInt" }, "data": { "description": "A series of data points which are decimal values separated by a single space (character u20). The special values \"E\" (error), \"L\" (below detection limit) and \"U\" (above detection limit) can also be used in place of a decimal value.", "$ref": "#/definitions/string" } }, "additionalProperties": false, "required": ["origin"] }, "Signature": { "description": "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.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "type": { "description": "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.", "items": { "$ref": "#/definitions/Coding" }, "type": "array" }, "when": { "description": "When the digital signature was signed.", "$ref": "#/definitions/instant" }, "who": { "description": "A reference to an application-usable description of the identity that signed (e.g. the signature used their private key).", "$ref": "#/definitions/Reference" }, "onBehalfOf": { "description": "A reference to an application-usable description of the identity that is represented by the signature.", "$ref": "#/definitions/Reference" }, "targetFormat": { "description": "A mime type that indicates the technical format of the target resources signed by the signature.", "$ref": "#/definitions/code" }, "sigFormat": { "description": "A mime type that indicates the technical format of the signature. Important mime types are application/signature+xml for X ML DigSig, application/jose for JWS, and image/* for a graphical image of a signature, etc.", "$ref": "#/definitions/code" }, "data": { "description": "The base64 encoding of the Signature content. When signature is not recorded electronically this element would be empty.", "$ref": "#/definitions/base64Binary" } }, "additionalProperties": false, "required": ["type", "who"] }, "Specimen": { "description": "A sample to be used for analysis.", "properties": { "resourceType": { "description": "This is a Specimen resource", "const": "Specimen" }, "id": { "description": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.", "$ref": "#/definitions/id" }, "meta": { "description": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.", "$ref": "#/definitions/Meta" }, "implicitRules": { "description": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content. Often, this is a reference to an implementation guide that defines the special rules along with other profiles etc.", "$ref": "#/definitions/uri" }, "language": { "description": "The base language in which the resource is written.", "$ref": "#/definitions/code" }, "text": { "description": "A human-readable narrative that contains a summary of the resource and can be used to represent the content of the resource to a human. The narrative need not encode all the structured data, but is required to contain sufficient detail to make it \"clinically safe\" for a human to just read the narrative. Resource definitions may define what content should be represented in the narrative to ensure clinical safety.", "$ref": "#/definitions/Narrative" }, "contained": { "description": "These resources do not have an independent existence apart from the resource that contains them - they cannot be identified independently, and nor can they have their own independent transaction scope.", "items": { "$ref": "#/definitions/ResourceList" }, "type": "array" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the resource. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "May be used to represent additional information that is not part of the basic definition of the resource and that modifies the understanding of the element that contains it and/or the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Applications processing a resource are required to check for modifier extensions.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "identifier": { "description": "Id for specimen.", "items": { "$ref": "#/definitions/Identifier" }, "type": "array" }, "accessionIdentifier": { "description": "The identifier assigned by the lab when accessioning specimen(s). This is not necessarily the same as the specimen identifier, depending on local lab procedures.", "$ref": "#/definitions/Identifier" }, "status": { "description": "The availability of the specimen.", "enum": ["available", "unavailable", "unsatisfactory", "entered-in-error"] }, "type": { "description": "The kind of material that forms the specimen.", "$ref": "#/definitions/CodeableConcept" }, "subject": { "description": "Where the specimen came from. This may be from patient(s), from a location (e.g., the source of an environmental sample), or a sampling of a substance or a device.", "$ref": "#/definitions/Reference" }, "receivedTime": { "description": "Time when specimen was received for processing or testing.", "$ref": "#/definitions/dateTime" }, "parent": { "description": "Reference to the parent (source) specimen which is used when the specimen was either derived from or a component of another specimen.", "items": { "$ref": "#/definitions/Reference" }, "type": "array" }, "request": { "description": "Details concerning a service request that required a specimen to be collected.", "items": { "$ref": "#/definitions/Reference" }, "type": "array" }, "collection": { "description": "Details concerning the specimen collection.", "$ref": "#/definitions/Specimen_Collection" }, "processing": { "description": "Details concerning processing and processing steps for the specimen.", "items": { "$ref": "#/definitions/Specimen_Processing" }, "type": "array" }, "container": { "description": "The container holding the specimen. The recursive nature of containers; i.e. blood in tube in tray in rack is not addressed here.", "items": { "$ref": "#/definitions/Specimen_Container" }, "type": "array" }, "condition": { "description": "A mode or state of being that describes the nature of the specimen.", "items": { "$ref": "#/definitions/CodeableConcept" }, "type": "array" }, "note": { "description": "To communicate any details or issues about the specimen or during the specimen collection. (for example: broken vial, sent with patient, frozen).", "items": { "$ref": "#/definitions/Annotation" }, "type": "array" } }, "additionalProperties": false, "required": ["resourceType"] }, "Specimen_Collection": { "description": "A sample to be used for analysis.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "collector": { "description": "Person who collected the specimen.", "$ref": "#/definitions/Reference" }, "collectedDateTime": { "description": "Time when specimen was collected from subject - the physiologically relevant time.", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$", "type": "string" }, "collectedPeriod": { "description": "Time when specimen was collected from subject - the physiologically relevant time.", "$ref": "#/definitions/Period" }, "duration": { "description": "The span of time over which the collection of a specimen occurred.", "$ref": "#/definitions/Duration" }, "quantity": { "description": "The quantity of specimen collected; for instance the volume of a blood sample, or the physical measurement of an anatomic pathology sample.", "$ref": "#/definitions/Quantity" }, "method": { "description": "A coded value specifying the technique that is used to perform the procedure.", "$ref": "#/definitions/CodeableConcept" }, "bodySite": { "description": "Anatomical location from which the specimen was collected (if subject is a patient). This is the target site. This element is not used for environmental specimens.", "$ref": "#/definitions/CodeableConcept" }, "fastingStatusCodeableConcept": { "description": "Abstinence or reduction from some or all food, drink, or both, for a period of time prior to sample collection.", "$ref": "#/definitions/CodeableConcept" }, "fastingStatusDuration": { "description": "Abstinence or reduction from some or all food, drink, or both, for a period of time prior to sample collection.", "$ref": "#/definitions/Duration" } }, "additionalProperties": false }, "Specimen_Container": { "description": "A sample to be used for analysis.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "identifier": { "description": "Id for container. There may be multiple; a manufacturer's bar code, lab assigned identifier, etc. The container ID may differ from the specimen id in some circumstances.", "items": { "$ref": "#/definitions/Identifier" }, "type": "array" }, "description": { "description": "Textual description of the container.", "$ref": "#/definitions/string" }, "type": { "description": "The type of container associated with the specimen (e.g. slide, aliquot, etc.).", "$ref": "#/definitions/CodeableConcept" }, "capacity": { "description": "The capacity (volume or other measure) the container may contain.", "$ref": "#/definitions/Quantity" }, "specimenQuantity": { "description": "The quantity of specimen in the container; may be volume, dimensions, or other appropriate measurements, depending on the specimen type.", "$ref": "#/definitions/Quantity" }, "additiveCodeableConcept": { "description": "Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.", "$ref": "#/definitions/CodeableConcept" }, "additiveReference": { "description": "Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.", "$ref": "#/definitions/Reference" } }, "additionalProperties": false }, "Specimen_Processing": { "description": "A sample to be used for analysis.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "description": { "description": "Textual description of procedure.", "$ref": "#/definitions/string" }, "procedure": { "description": "A coded value specifying the procedure used to process the specimen.", "$ref": "#/definitions/CodeableConcept" }, "additive": { "description": "Material used in the processing step.", "items": { "$ref": "#/definitions/Reference" }, "type": "array" }, "timeDateTime": { "description": "A record of the time or period when the specimen processing occurred. For example the time of sample fixation or the period of time the sample was in formalin.", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$", "type": "string" }, "timePeriod": { "description": "A record of the time or period when the specimen processing occurred. For example the time of sample fixation or the period of time the sample was in formalin.", "$ref": "#/definitions/Period" } }, "additionalProperties": false }, "Timing": { "description": "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.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "event": { "description": "Identifies specific times when the event occurs.", "items": { "$ref": "#/definitions/dateTime" }, "type": "array" }, "repeat": { "description": "A set of rules that describe when the event is scheduled.", "$ref": "#/definitions/Timing_Repeat" }, "code": { "description": "A code for the timing schedule (or just text in code.text). Some codes such as BID are ubiquitous, but many institutions define their own additional codes. If a code is provided, the code is understood to be a complete statement of whatever is specified in the structured timing data, and either the code or the data may be used to interpret the Timing, with the exception that .repeat.bounds still applies over the code (and is not contained in the code).", "$ref": "#/definitions/CodeableConcept" } }, "additionalProperties": false }, "Timing_Repeat": { "description": "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.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "modifierExtension": { "description": "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.\n\nModifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "boundsDuration": { "description": "Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule.", "$ref": "#/definitions/Duration" }, "boundsRange": { "description": "Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule.", "$ref": "#/definitions/Range" }, "boundsPeriod": { "description": "Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule.", "$ref": "#/definitions/Period" }, "count": { "description": "A total count of the desired number of repetitions across the duration of the entire timing specification. If countMax is present, this element indicates the lower bound of the allowed range of count values.", "$ref": "#/definitions/positiveInt" }, "countMax": { "description": "If present, indicates that the count is a range - so to perform the action between [count] and [countMax] times.", "$ref": "#/definitions/positiveInt" }, "duration": { "description": "How long this thing happens for when it happens. If durationMax is present, this element indicates the lower bound of the allowed range of the duration.", "$ref": "#/definitions/decimal" }, "durationMax": { "description": "If present, indicates that the duration is a range - so to perform the action between [duration] and [durationMax] time length.", "$ref": "#/definitions/decimal" }, "durationUnit": { "description": "The units of time for the duration, in UCUM units.", "enum": ["s", "min", "h", "d", "wk", "mo", "a"] }, "frequency": { "description": "The number of times to repeat the action within the specified period. If frequencyMax is present, this element indicates the lower bound of the allowed range of the frequency.", "$ref": "#/definitions/positiveInt" }, "frequencyMax": { "description": "If present, indicates that the frequency is a range - so to repeat between [frequency] and [frequencyMax] times within the period or period range.", "$ref": "#/definitions/positiveInt" }, "period": { "description": "Indicates the duration of time over which repetitions are to occur; e.g. to express \"3 times per day\", 3 would be the frequency and \"1 day\" would be the period. If periodMax is present, this element indicates the lower bound of the allowed range of the period length.", "$ref": "#/definitions/decimal" }, "periodMax": { "description": "If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as \"do this once every 3-5 days.", "$ref": "#/definitions/decimal" }, "periodUnit": { "description": "The units of time for the period in UCUM units.", "enum": ["s", "min", "h", "d", "wk", "mo", "a"] }, "dayOfWeek": { "description": "If one or more days of week is provided, then the action happens only on the specified day(s).", "items": { "$ref": "#/definitions/code" }, "type": "array" }, "timeOfDay": { "description": "Specified time of day for action to take place.", "items": { "$ref": "#/definitions/time" }, "type": "array" }, "when": { "description": "An approximate time period during the day, potentially linked to an event of daily living that indicates when the action should occur.", "items": { "enum": [ "MORN", "MORN.early", "MORN.late", "NOON", "AFT", "AFT.early", "AFT.late", "EVE", "EVE.early", "EVE.late", "NIGHT", "PHS", "HS", "WAKE", "C", "CM", "CD", "CV", "AC", "ACM", "ACD", "ACV", "PC", "PCM", "PCD", "PCV" ] }, "type": "array" }, "offset": { "description": "The number of minutes from the event. If the event code does not indicate whether the minutes is before or after the event, then the offset is assumed to be after the event.", "$ref": "#/definitions/unsignedInt" } }, "additionalProperties": false }, "TriggerDefinition": { "description": "A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "type": { "description": "The type of triggering event.", "enum": [ "named-event", "periodic", "data-changed", "data-added", "data-modified", "data-removed", "data-accessed", "data-access-ended" ] }, "name": { "description": "A formal name for the event. This may be an absolute URI that identifies the event formally (e.g. from a trigger registry), or a simple relative URI that identifies the event in a local context.", "$ref": "#/definitions/string" }, "timingTiming": { "description": "The timing of the event (if this is a periodic trigger).", "$ref": "#/definitions/Timing" }, "timingReference": { "description": "The timing of the event (if this is a periodic trigger).", "$ref": "#/definitions/Reference" }, "timingDate": { "description": "The timing of the event (if this is a periodic trigger).", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1]))?)?$", "type": "string" }, "timingDateTime": { "description": "The timing of the event (if this is a periodic trigger).", "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$", "type": "string" }, "data": { "description": "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.", "items": { "$ref": "#/definitions/DataRequirement" }, "type": "array" }, "condition": { "description": "A boolean-valued expression that is evaluated in the context of the container of the trigger definition and returns whether or not the trigger fires.", "$ref": "#/definitions/Expression" } }, "additionalProperties": false }, "UsageContext": { "description": "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).", "properties": { "id": { "description": "Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.", "$ref": "#/definitions/string" }, "extension": { "description": "May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.", "items": { "$ref": "#/definitions/Extension" }, "type": "array" }, "code": { "description": "A code that identifies the type of context being specified by this usage context.", "$ref": "#/definitions/Coding" }, "valueCodeableConcept": { "description": "A value that defines the context specified in this context of use. The interpretation of the value is defined by the code.", "$ref": "#/definitions/CodeableConcept" }, "valueQuantity": { "description": "A value that defines the context specified in this context of use. The interpretation of the value is defined by the code.", "$ref": "#/definitions/Quantity" }, "valueRange": { "description": "A value that defines the context specified in this context of use. The interpretation of the value is defined by the code.", "$ref": "#/definitions/Range" }, "valueReference": { "description": "A value that defines the context specified in this context of use. The interpretation of the value is defined by the code.", "$ref": "#/definitions/Reference" } }, "additionalProperties": false, "required": ["code"] }, "base64Binary": { "type": "string", "description": "A stream of bytes" }, "boolean": { "pattern": "^true|false$", "type": "boolean", "description": "Value of \"true\" or \"false\"" }, "canonical": { "pattern": "^\\S*$", "type": "string", "description": "A URI that is a reference to a canonical URL on a FHIR resource" }, "code": { "pattern": "^[^\\s]+(\\s[^\\s]+)*$", "type": "string", "description": "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" }, "date": { "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1]))?)?$", "type": "string", "description": "A date or partial date (e.g. just year or year + month). There is no time zone. The format is a union of the schema types gYear, gYearMonth and date. Dates SHALL be valid dates." }, "dateTime": { "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)(-(0[1-9]|1[0-2])(-(0[1-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))?)?)?$", "type": "string", "description": "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." }, "decimal": { "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$", "type": "number", "description": "A rational number with implicit precision" }, "id": { "pattern": "^[A-Za-z0-9\\-\\.]{1,64}$", "type": "string", "description": "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." }, "instant": { "pattern": "^([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))$", "type": "string", "description": "An instant in time - known at least to the second" }, "integer": { "pattern": "^-?([0]|([1-9][0-9]*))$", "type": "number", "description": "A whole number" }, "markdown": { "pattern": "^[ \\r\\n\\t\\S]+$", "type": "string", "description": "A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine" }, "positiveInt": { "pattern": "^[1-9][0-9]*$", "type": "number", "description": "An integer with a value that is positive (e.g. >0)" }, "string": { "pattern": "^[ \\r\\n\\t\\S]+$", "type": "string", "description": "A sequence of Unicode characters" }, "time": { "pattern": "^([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\\.[0-9]+)?$", "type": "string", "description": "A time during the day, with no date specified" }, "unsignedInt": { "pattern": "^[0]|([1-9][0-9]*)$", "type": "number", "description": "An integer with a value that is not negative (e.g. >= 0)" }, "uri": { "pattern": "^\\S*$", "type": "string", "description": "String of characters used to identify a name or a resource" }, "url": { "pattern": "^\\S*$", "type": "string", "description": "A URI that is a literal reference" }, "xhtml": { "description": "xhtml - escaped html (see specfication)" } } }