formbuilder-lhcforms 10.2.1 → 10.3.1

package/dist/formbuilder-lhcforms/assets/ngx-vs.schema.json5

@@ -0,0 +1,3866 @@
+{
+  "description": "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).",
+  "properties": {
+    "resourceType": {
+      "description": "This is a ValueSet resource",
+      "type": "string",
+      "enum": [
+        "ValueSet"
+      ],
+      "title": "Resource type"
+    },
+    "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",
+      "title": "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",
+      "title": "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",
+      "title": "Implicit rules"
+    },
+    "_implicitRules": {
+      "description": "Extensions for implicitRules",
+      "$ref": "#/definitions/Element",
+      "title": "_implicit rules"
+    },
+    "language": {
+      "description": "The base language in which the resource is written.",
+      "$ref": "#/definitions/code",
+      "title": "Language"
+    },
+    "_language": {
+      "description": "Extensions for language",
+      "$ref": "#/definitions/Element",
+      "title": "_language"
+    },
+    /*
+    "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",
+      "title": "Text"
+    },
+    */
+    "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",
+      "title": "Extension"
+    },
+    "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",
+      "title": "Modifier extension"
+    },
+    "url": {
+      "description": "An absolute URI that is used to identify this value set when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this value set is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the value set is stored on different servers.",
+      "$ref": "#/definitions/uri",
+      "title": "Url"
+    },
+    "_url": {
+      "description": "Extensions for url",
+      "$ref": "#/definitions/Element",
+      "title": "_url"
+    },
+    "identifier": {
+      "description": "A formal identifier that is used to identify this value set when it is represented in other formats, or referenced in a specification, model, design or an instance.",
+      "items": {
+        "$ref": "#/definitions/Identifier"
+      },
+      "type": "array",
+      "title": "Identifier"
+    },
+    "version": {
+      "description": "The identifier that is used to identify this version of the value set when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the value set author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
+      "$ref": "#/definitions/string",
+      "title": "Version"
+    },
+    "_version": {
+      "description": "Extensions for version",
+      "$ref": "#/definitions/Element",
+      "title": "_version"
+    },
+    "name": {
+      "description": "A natural language name identifying the value set. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
+      "$ref": "#/definitions/string",
+      "title": "Name"
+    },
+    "_name": {
+      "description": "Extensions for name",
+      "$ref": "#/definitions/Element",
+      "title": "_name"
+    },
+    "title": {
+      "description": "A short, descriptive, user-friendly title for the value set.",
+      "$ref": "#/definitions/string",
+      "title": "Title"
+    },
+    "_title": {
+      "description": "Extensions for title",
+      "$ref": "#/definitions/Element",
+      "title": "_title"
+    },
+    "status": {
+      "description": "The status of this value set. Enables tracking the life-cycle of the content. The status of the value set applies to the value set definition (ValueSet.compose) and the associated ValueSet metadata. Expansions do not have a state.",
+      "enum": [
+        "draft",
+        "active",
+        "retired",
+        "unknown"
+      ],
+      "type": "string",
+      "title": "Status"
+    },
+    "_status": {
+      "description": "Extensions for status",
+      "$ref": "#/definitions/Element",
+      "title": "_status"
+    },
+    "experimental": {
+      "description": "A Boolean value to indicate that this value set is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.",
+      "$ref": "#/definitions/boolean",
+      "title": "Experimental"
+    },
+    "_experimental": {
+      "description": "Extensions for experimental",
+      "$ref": "#/definitions/Element",
+      "title": "_experimental"
+    },
+    "date": {
+      "description": "The date (and optionally time) when the value set was created or revised (e.g. the 'content logical definition').",
+      "$ref": "#/definitions/dateTime",
+      "title": "Date"
+    },
+    "_date": {
+      "description": "Extensions for date",
+      "$ref": "#/definitions/Element",
+      "title": "_date"
+    },
+    "publisher": {
+      "description": "The name of the organization or individual that published the value set.",
+      "$ref": "#/definitions/string",
+      "title": "Publisher"
+    },
+    "_publisher": {
+      "description": "Extensions for publisher",
+      "$ref": "#/definitions/Element",
+      "title": "_publisher"
+    },
+    "contact": {
+      "description": "Contact details to assist a user in finding and communicating with the publisher.",
+      "items": {
+        "$ref": "#/definitions/ContactDetail"
+      },
+      "type": "array",
+      "title": "Contact"
+    },
+    "description": {
+      "description": "A free text natural language description of the value set from a consumer's perspective. The textual description specifies the span of meanings for concepts to be included within the Value Set Expansion, and also may specify the intended use and limitations of the Value Set.",
+      "$ref": "#/definitions/markdown",
+      "title": "Description"
+    },
+    "_description": {
+      "description": "Extensions for description",
+      "$ref": "#/definitions/Element",
+      "title": "_description"
+    },
+    "useContext": {
+      "description": "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate value set instances.",
+      "items": {
+        "$ref": "#/definitions/UsageContext"
+      },
+      "type": "array",
+      "title": "Use context"
+    },
+    "jurisdiction": {
+      "description": "A legal or geographic region in which the value set is intended to be used.",
+      "items": {
+        "$ref": "#/definitions/CodeableConcept"
+      },
+      "type": "array",
+      "title": "Jurisdiction"
+    },
+    "immutable": {
+      "description": "If this is set to 'true', then no new versions of the content logical definition can be created.  Note: Other metadata might still change.",
+      "$ref": "#/definitions/boolean",
+      "title": "Immutable"
+    },
+    "_immutable": {
+      "description": "Extensions for immutable",
+      "$ref": "#/definitions/Element",
+      "title": "_immutable"
+    },
+    "purpose": {
+      "description": "Explanation of why this value set is needed and why it has been designed as it has.",
+      "$ref": "#/definitions/markdown",
+      "title": "Purpose"
+    },
+    "_purpose": {
+      "description": "Extensions for purpose",
+      "$ref": "#/definitions/Element",
+      "title": "_purpose"
+    },
+    "copyright": {
+      "description": "A copyright statement relating to the value set and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the value set.",
+      "$ref": "#/definitions/markdown",
+      "title": "Copyright"
+    },
+    "_copyright": {
+      "description": "Extensions for copyright",
+      "$ref": "#/definitions/Element",
+      "title": "_copyright"
+    },
+    "compose": {
+      "description": "A set of criteria that define the contents of the value set by including or excluding codes selected from the specified code system(s) that the value set draws from. This is also known as the Content Logical Definition (CLD).",
+      "$ref": "#/definitions/ValueSet_Compose",
+      "title": "Compose"
+    },
+    "expansion": {
+      "description": "A value set can also be \"expanded\", where the value set is turned into a simple collection of enumerated codes. This element holds the expansion, if it has been performed.",
+      "$ref": "#/definitions/ValueSet_Expansion",
+      "title": "Expansion"
+    }
+  },
+  "additionalProperties": true,
+  "required": [
+    "resourceType"
+  ],
+  "type": "object",
+  "widget": {
+    "keyField": "/resourceType",
+    "id": "row-layout"
+  },
+  "definitions": {
+    "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."
+    },
+    "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",
+          "widget": {
+            "id": "hidden"
+          }
+        },
+        "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,
+      "type": "object"
+    },
+    "string": {
+      "pattern": "^[ \\r\\n\\t\\S]+$",
+      "type": "string"
+    },
+    "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.",
+          "pattern": "^[ \\r\\n\\t\\S]+$",
+          "type": "string",
+          "widget": {
+            "id": "hidden"
+          }
+        },
+        "url": {
+          "description": "Source of the definition for the extension code - a logical name or a URL.",
+          "pattern": "^\\S*$",
+          "type": "string"
+        },
+        "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).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "use": {
+              "description": "The purpose of this address.",
+              "enum": [
+                "home",
+                "work",
+                "temp",
+                "old",
+                "billing"
+              ],
+              "type": "string"
+            },
+            "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"
+              ],
+              "type": "string"
+            },
+            "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "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": {
+                "pattern": "^[ \\r\\n\\t\\S]+$",
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "city": {
+              "description": "The name of the city, town, suburb, village or other community or delivery center.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "district": {
+              "description": "The name of the administrative area (county).",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "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).",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "postalCode": {
+              "description": "A postal code designating a region defined by the postal service.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "country": {
+              "description": "Country - a nation as commonly understood or generally accepted.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "period": {
+              "description": "Time period when address was/is in use.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "start": {
+                  "description": "The start of the period. The boundary is inclusive.",
+                  "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"
+                },
+                "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.",
+                  "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"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueAge": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "value": {
+              "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+              "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+              "type": "number"
+            },
+            "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": [
+                "<",
+                "<=",
+                ">=",
+                ">"
+              ],
+              "type": "string"
+            },
+            "unit": {
+              "description": "A human-readable form of the unit.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "system": {
+              "description": "The identification of the system that provides the coded form of the unit.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            },
+            "code": {
+              "description": "A computer processable form of the unit in some unit representation system.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueAnnotation": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "authorReference": {
+              "description": "The individual responsible for making the annotation.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "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).",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "display": {
+                  "description": "Plain text narrative that identifies the resource in addition to the resource reference.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            },
+            "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.",
+              "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"
+            },
+            "text": {
+              "description": "The text of the annotation in markdown format.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueAttachment": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "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.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            },
+            "language": {
+              "description": "The human language of the content. The value can be any valid value according to BCP 47.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            },
+            "data": {
+              "description": "The actual data of the attachment - a sequence of bytes, base64 encoded.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "url": {
+              "description": "A location where the data can be accessed.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            },
+            "size": {
+              "description": "The number of bytes of data that make up this attachment (before base64 encoding, if that is done).",
+              "pattern": "^[0]|([1-9][0-9]*)$",
+              "type": "number"
+            },
+            "hash": {
+              "description": "The calculated hash of the data using SHA-1. Represented using base64.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "title": {
+              "description": "A label or set of text to display in place of the data.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "creation": {
+              "description": "The date that the attachment was first created.",
+              "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"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueCodeableConcept": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "coding": {
+              "description": "A reference to a code defined by a terminology system.",
+              "items": {
+                "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.",
+                    "widget": {
+                      "id": "hidden"
+                    },
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "string"
+                  },
+                  "system": {
+                    "description": "The identification of the code system that defines the meaning of the symbol in the code.",
+                    "pattern": "^\\S*$",
+                    "type": "string"
+                  },
+                  "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.",
+                    "widget": {
+                      "id": "hidden"
+                    },
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "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).",
+                    "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                    "type": "string"
+                  },
+                  "display": {
+                    "description": "A representation of the meaning of the code in the system, following the rules of the system.",
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "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).",
+                    "pattern": "^true|false$",
+                    "type": "boolean"
+                  }
+                },
+                "additionalProperties": false,
+                "type": "object",
+                "widget": {
+                  "id": "row-layout"
+                },
+                "fieldsets": [
+                  {
+                    "fields": [
+                      "id",
+                      "system",
+                      "version",
+                      "code",
+                      "display",
+                      "userSelected"
+                    ],
+                    "showFields": [
+                      {
+                        "code": {
+                          "col": 2
+                        }
+                      },
+                      {
+                        "system": {
+                          "col": 6
+                        }
+                      },
+                      {
+                        "display": {
+                          "col": 4
+                        }
+                      }
+                    ]
+                  }
+                ]
+              },
+              "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueCoding": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "widget": {
+                "id": "hidden"
+              },
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "system": {
+              "description": "The identification of the code system that defines the meaning of the symbol in the code.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            },
+            "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.",
+              "widget": {
+                "id": "hidden"
+              },
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "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).",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            },
+            "display": {
+              "description": "A representation of the meaning of the code in the system, following the rules of the system.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "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).",
+              "pattern": "^true|false$",
+              "type": "boolean"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object",
+          "widget": {
+            "id": "row-layout"
+          },
+          "fieldsets": [
+            {
+              "fields": [
+                "id",
+                "system",
+                "version",
+                "code",
+                "display",
+                "userSelected"
+              ],
+              "showFields": [
+                {
+                  "code": {
+                    "col": 2
+                  }
+                },
+                {
+                  "system": {
+                    "col": 6
+                  }
+                },
+                {
+                  "display": {
+                    "col": 4
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "valueContactPoint": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "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"
+              ],
+              "type": "string"
+            },
+            "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).",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "use": {
+              "description": "Identifies the purpose for the contact point.",
+              "enum": [
+                "home",
+                "work",
+                "temp",
+                "old",
+                "mobile"
+              ],
+              "type": "string"
+            },
+            "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.",
+              "pattern": "^[1-9][0-9]*$",
+              "type": "number"
+            },
+            "period": {
+              "description": "Time period when the contact point was/is in use.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "start": {
+                  "description": "The start of the period. The boundary is inclusive.",
+                  "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"
+                },
+                "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.",
+                  "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"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueCount": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "value": {
+              "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+              "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+              "type": "number"
+            },
+            "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": [
+                "<",
+                "<=",
+                ">=",
+                ">"
+              ],
+              "type": "string"
+            },
+            "unit": {
+              "description": "A human-readable form of the unit.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "system": {
+              "description": "The identification of the system that provides the coded form of the unit.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            },
+            "code": {
+              "description": "A computer processable form of the unit in some unit representation system.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueDistance": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "value": {
+              "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+              "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+              "type": "number"
+            },
+            "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": [
+                "<",
+                "<=",
+                ">=",
+                ">"
+              ],
+              "type": "string"
+            },
+            "unit": {
+              "description": "A human-readable form of the unit.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "system": {
+              "description": "The identification of the system that provides the coded form of the unit.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            },
+            "code": {
+              "description": "A computer processable form of the unit in some unit representation system.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueDuration": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "value": {
+              "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+              "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+              "type": "number"
+            },
+            "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": [
+                "<",
+                "<=",
+                ">=",
+                ">"
+              ],
+              "type": "string"
+            },
+            "unit": {
+              "description": "A human-readable form of the unit.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "system": {
+              "description": "The identification of the system that provides the coded form of the unit.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            },
+            "code": {
+              "description": "A computer processable form of the unit in some unit representation system.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueHumanName": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "use": {
+              "description": "Identifies the purpose for this name.",
+              "enum": [
+                "usual",
+                "official",
+                "temp",
+                "nickname",
+                "anonymous",
+                "old",
+                "maiden"
+              ],
+              "type": "string"
+            },
+            "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "given": {
+              "description": "Given name.",
+              "items": {
+                "pattern": "^[ \\r\\n\\t\\S]+$",
+                "type": "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": {
+                "pattern": "^[ \\r\\n\\t\\S]+$",
+                "type": "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": {
+                "pattern": "^[ \\r\\n\\t\\S]+$",
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "period": {
+              "description": "Indicates the period of time when this name was valid for the named person.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "start": {
+                  "description": "The start of the period. The boundary is inclusive.",
+                  "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"
+                },
+                "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.",
+                  "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"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueIdentifier": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "use": {
+              "description": "The purpose of this identifier.",
+              "enum": [
+                "usual",
+                "official",
+                "temp",
+                "secondary",
+                "old"
+              ],
+              "type": "string"
+            },
+            "type": {
+              "description": "A coded type for the identifier that can be used to determine which identifier to use for a specific purpose.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "coding": {
+                  "description": "A reference to a code defined by a terminology system.",
+                  "items": {
+                    "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.",
+                        "widget": {
+                          "id": "hidden"
+                        },
+                        "pattern": "^[ \\r\\n\\t\\S]+$",
+                        "type": "string"
+                      },
+                      "system": {
+                        "description": "The identification of the code system that defines the meaning of the symbol in the code.",
+                        "pattern": "^\\S*$",
+                        "type": "string"
+                      },
+                      "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.",
+                        "widget": {
+                          "id": "hidden"
+                        },
+                        "pattern": "^[ \\r\\n\\t\\S]+$",
+                        "type": "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).",
+                        "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                        "type": "string"
+                      },
+                      "display": {
+                        "description": "A representation of the meaning of the code in the system, following the rules of the system.",
+                        "pattern": "^[ \\r\\n\\t\\S]+$",
+                        "type": "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).",
+                        "pattern": "^true|false$",
+                        "type": "boolean"
+                      }
+                    },
+                    "additionalProperties": false,
+                    "type": "object",
+                    "widget": {
+                      "id": "row-layout"
+                    },
+                    "fieldsets": [
+                      {
+                        "fields": [
+                          "id",
+                          "system",
+                          "version",
+                          "code",
+                          "display",
+                          "userSelected"
+                        ],
+                        "showFields": [
+                          {
+                            "code": {
+                              "col": 2
+                            }
+                          },
+                          {
+                            "system": {
+                              "col": 6
+                            }
+                          },
+                          {
+                            "display": {
+                              "col": 4
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  },
+                  "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            },
+            "system": {
+              "description": "Establishes the namespace for the value - that is, a URL that describes a set values that are unique.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            },
+            "value": {
+              "description": "The portion of the identifier typically relevant to the user and which is unique within the context of the system.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "period": {
+              "description": "Time period during which identifier is/was valid for use.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "start": {
+                  "description": "The start of the period. The boundary is inclusive.",
+                  "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"
+                },
+                "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.",
+                  "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"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            },
+            "assigner": {
+              "description": "Organization that issued/manages the identifier.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "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).",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "display": {
+                  "description": "Plain text narrative that identifies the resource in addition to the resource reference.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueMoney": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "value": {
+              "description": "Numerical value (with implicit precision).",
+              "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+              "type": "number"
+            },
+            "currency": {
+              "description": "ISO 4217 Currency Code.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valuePeriod": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "start": {
+              "description": "The start of the period. The boundary is inclusive.",
+              "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"
+            },
+            "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.",
+              "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"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueQuantity": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "value": {
+              "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+              "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+              "type": "number"
+            },
+            "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": [
+                "<",
+                "<=",
+                ">=",
+                ">"
+              ],
+              "type": "string"
+            },
+            "unit": {
+              "description": "A human-readable form of the unit.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "system": {
+              "description": "The identification of the system that provides the coded form of the unit.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            },
+            "code": {
+              "description": "A computer processable form of the unit in some unit representation system.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueRange": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "low": {
+              "description": "The low limit. The boundary is inclusive.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "value": {
+                  "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+                  "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+                  "type": "number"
+                },
+                "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": [
+                    "<",
+                    "<=",
+                    ">=",
+                    ">"
+                  ],
+                  "type": "string"
+                },
+                "unit": {
+                  "description": "A human-readable form of the unit.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "system": {
+                  "description": "The identification of the system that provides the coded form of the unit.",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "code": {
+                  "description": "A computer processable form of the unit in some unit representation system.",
+                  "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            },
+            "high": {
+              "description": "The high limit. The boundary is inclusive.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "value": {
+                  "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+                  "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+                  "type": "number"
+                },
+                "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": [
+                    "<",
+                    "<=",
+                    ">=",
+                    ">"
+                  ],
+                  "type": "string"
+                },
+                "unit": {
+                  "description": "A human-readable form of the unit.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "system": {
+                  "description": "The identification of the system that provides the coded form of the unit.",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "code": {
+                  "description": "A computer processable form of the unit in some unit representation system.",
+                  "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueRatio": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "numerator": {
+              "description": "The value of the numerator.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "value": {
+                  "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+                  "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+                  "type": "number"
+                },
+                "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": [
+                    "<",
+                    "<=",
+                    ">=",
+                    ">"
+                  ],
+                  "type": "string"
+                },
+                "unit": {
+                  "description": "A human-readable form of the unit.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "system": {
+                  "description": "The identification of the system that provides the coded form of the unit.",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "code": {
+                  "description": "A computer processable form of the unit in some unit representation system.",
+                  "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            },
+            "denominator": {
+              "description": "The value of the 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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "value": {
+                  "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+                  "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+                  "type": "number"
+                },
+                "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": [
+                    "<",
+                    "<=",
+                    ">=",
+                    ">"
+                  ],
+                  "type": "string"
+                },
+                "unit": {
+                  "description": "A human-readable form of the unit.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "system": {
+                  "description": "The identification of the system that provides the coded form of the unit.",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "code": {
+                  "description": "A computer processable form of the unit in some unit representation system.",
+                  "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueReference": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "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).",
+              "pattern": "^\\S*$",
+              "type": "string"
+            },
+            "display": {
+              "description": "Plain text narrative that identifies the resource in addition to the resource reference.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueSampledData": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "origin": {
+              "description": "The base quantity that a measured value of zero represents. In addition, this provides the units of the entire measurement series.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "value": {
+                  "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+                  "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+                  "type": "number"
+                },
+                "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": [
+                    "<",
+                    "<=",
+                    ">=",
+                    ">"
+                  ],
+                  "type": "string"
+                },
+                "unit": {
+                  "description": "A human-readable form of the unit.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "system": {
+                  "description": "The identification of the system that provides the coded form of the unit.",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "code": {
+                  "description": "A computer processable form of the unit in some unit representation system.",
+                  "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            },
+            "period": {
+              "description": "The length of time between sampling times, measured in milliseconds.",
+              "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+              "type": "number"
+            },
+            "factor": {
+              "description": "A correction factor that is applied to the sampled data points before they are added to the origin.",
+              "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+              "type": "number"
+            },
+            "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).",
+              "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+              "type": "number"
+            },
+            "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).",
+              "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+              "type": "number"
+            },
+            "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.",
+              "pattern": "^[1-9][0-9]*$",
+              "type": "number"
+            },
+            "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "origin"
+          ],
+          "type": "object"
+        },
+        "valueSignature": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "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": {
+                "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.",
+                    "widget": {
+                      "id": "hidden"
+                    },
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "string"
+                  },
+                  "system": {
+                    "description": "The identification of the code system that defines the meaning of the symbol in the code.",
+                    "pattern": "^\\S*$",
+                    "type": "string"
+                  },
+                  "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.",
+                    "widget": {
+                      "id": "hidden"
+                    },
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "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).",
+                    "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                    "type": "string"
+                  },
+                  "display": {
+                    "description": "A representation of the meaning of the code in the system, following the rules of the system.",
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "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).",
+                    "pattern": "^true|false$",
+                    "type": "boolean"
+                  }
+                },
+                "additionalProperties": false,
+                "type": "object",
+                "widget": {
+                  "id": "row-layout"
+                },
+                "fieldsets": [
+                  {
+                    "fields": [
+                      "id",
+                      "system",
+                      "version",
+                      "code",
+                      "display",
+                      "userSelected"
+                    ],
+                    "showFields": [
+                      {
+                        "code": {
+                          "col": 2
+                        }
+                      },
+                      {
+                        "system": {
+                          "col": 6
+                        }
+                      },
+                      {
+                        "display": {
+                          "col": 4
+                        }
+                      }
+                    ]
+                  }
+                ]
+              },
+              "type": "array"
+            },
+            "when": {
+              "description": "When the digital signature was signed.",
+              "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"
+            },
+            "who": {
+              "description": "A reference to an application-usable description of the identity that signed  (e.g. the signature used their private key).",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "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).",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "display": {
+                  "description": "Plain text narrative that identifies the resource in addition to the resource reference.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            },
+            "onBehalfOf": {
+              "description": "A reference to an application-usable description of the identity that is represented by the signature.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "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).",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "display": {
+                  "description": "Plain text narrative that identifies the resource in addition to the resource reference.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            },
+            "targetFormat": {
+              "description": "A mime type that indicates the technical format of the target resources signed by the signature.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            },
+            "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.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            },
+            "data": {
+              "description": "The base64 encoding of the Signature content. When signature is not recorded electronically this element would be empty.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "type",
+            "who"
+          ],
+          "type": "object"
+        },
+        "valueContactDetail": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "name": {
+              "description": "The name of an individual to contact.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "telecom": {
+              "description": "The contact details for the individual (if a name was provided) or the organization.",
+              "items": {
+                "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.",
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "string"
+                  },
+                  "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"
+                    ],
+                    "type": "string"
+                  },
+                  "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).",
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "string"
+                  },
+                  "use": {
+                    "description": "Identifies the purpose for the contact point.",
+                    "enum": [
+                      "home",
+                      "work",
+                      "temp",
+                      "old",
+                      "mobile"
+                    ],
+                    "type": "string"
+                  },
+                  "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.",
+                    "pattern": "^[1-9][0-9]*$",
+                    "type": "number"
+                  },
+                  "period": {
+                    "description": "Time period when the contact point was/is in use.",
+                    "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.",
+                        "pattern": "^[ \\r\\n\\t\\S]+$",
+                        "type": "string"
+                      },
+                      "start": {
+                        "description": "The start of the period. The boundary is inclusive.",
+                        "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"
+                      },
+                      "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.",
+                        "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"
+                      }
+                    },
+                    "additionalProperties": false,
+                    "type": "object"
+                  }
+                },
+                "additionalProperties": false,
+                "type": "object"
+              },
+              "type": "array"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueContributor": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "type": {
+              "description": "The type of contributor.",
+              "enum": [
+                "author",
+                "editor",
+                "reviewer",
+                "endorser"
+              ],
+              "type": "string"
+            },
+            "name": {
+              "description": "The name of the individual or organization responsible for the contribution.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "contact": {
+              "description": "Contact details to assist a user in finding and communicating with the contributor.",
+              "items": {
+                "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.",
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "string"
+                  },
+                  "name": {
+                    "description": "The name of an individual to contact.",
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "string"
+                  },
+                  "telecom": {
+                    "description": "The contact details for the individual (if a name was provided) or the organization.",
+                    "items": {
+                      "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.",
+                          "pattern": "^[ \\r\\n\\t\\S]+$",
+                          "type": "string"
+                        },
+                        "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"
+                          ],
+                          "type": "string"
+                        },
+                        "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).",
+                          "pattern": "^[ \\r\\n\\t\\S]+$",
+                          "type": "string"
+                        },
+                        "use": {
+                          "description": "Identifies the purpose for the contact point.",
+                          "enum": [
+                            "home",
+                            "work",
+                            "temp",
+                            "old",
+                            "mobile"
+                          ],
+                          "type": "string"
+                        },
+                        "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.",
+                          "pattern": "^[1-9][0-9]*$",
+                          "type": "number"
+                        },
+                        "period": {
+                          "description": "Time period when the contact point was/is in use.",
+                          "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.",
+                              "pattern": "^[ \\r\\n\\t\\S]+$",
+                              "type": "string"
+                            },
+                            "start": {
+                              "description": "The start of the period. The boundary is inclusive.",
+                              "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"
+                            },
+                            "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.",
+                              "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"
+                            }
+                          },
+                          "additionalProperties": false,
+                          "type": "object"
+                        }
+                      },
+                      "additionalProperties": false,
+                      "type": "object"
+                    },
+                    "type": "array"
+                  }
+                },
+                "additionalProperties": false,
+                "type": "object"
+              },
+              "type": "array"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueExpression": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "description": {
+              "description": "A brief, natural language description of the condition that effectively communicates the intended semantics.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "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.",
+              "pattern": "^[A-Za-z0-9\\-\\.]{1,64}$",
+              "type": "string"
+            },
+            "language": {
+              "description": "The media type of the language for the expression.",
+              "enum": [
+                "text/cql",
+                "text/fhirpath",
+                "application/x-fhir-query"
+              ],
+              "type": "string"
+            },
+            "expression": {
+              "description": "An expression in the specified language that returns a value.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "reference": {
+              "description": "A URI that defines where the expression is found.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueParameterDefinition": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "name": {
+              "description": "The name of the parameter used to allow access to the value of the parameter in evaluation contexts.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            },
+            "use": {
+              "description": "Whether the parameter is input or output for the module.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            },
+            "min": {
+              "description": "The minimum number of times this parameter SHALL appear in the request or response.",
+              "pattern": "^-?([0]|([1-9][0-9]*))$",
+              "type": "number"
+            },
+            "max": {
+              "description": "The maximum number of times this element is permitted to appear in the request or response.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "documentation": {
+              "description": "A brief discussion of what the parameter is for and how it is used by the module.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "type": {
+              "description": "The type of the parameter.",
+              "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+              "type": "string"
+            },
+            "profile": {
+              "description": "If specified, this indicates a profile that the input data must conform to, or that the output data will conform to.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueRelatedArtifact": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "type": {
+              "description": "The type of relationship to the related artifact.",
+              "enum": [
+                "documentation",
+                "justification",
+                "citation",
+                "predecessor",
+                "successor",
+                "derived-from",
+                "depends-on",
+                "composed-of"
+              ],
+              "type": "string"
+            },
+            "label": {
+              "description": "A short label that can be used to reference the citation from elsewhere in the containing artifact, such as a footnote index.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "display": {
+              "description": "A brief description of the document or knowledge resource being referenced, suitable for display to a consumer.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "citation": {
+              "description": "A bibliographic citation for the related artifact. This text SHOULD be formatted according to an accepted citation format.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "url": {
+              "description": "A url for the artifact that can be followed to access the actual content.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            },
+            "document": {
+              "description": "The document being referenced, represented as an attachment. This is exclusive with the resource 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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "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.",
+                  "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                  "type": "string"
+                },
+                "language": {
+                  "description": "The human language of the content. The value can be any valid value according to BCP 47.",
+                  "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                  "type": "string"
+                },
+                "data": {
+                  "description": "The actual data of the attachment - a sequence of bytes, base64 encoded.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "url": {
+                  "description": "A location where the data can be accessed.",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "size": {
+                  "description": "The number of bytes of data that make up this attachment (before base64 encoding, if that is done).",
+                  "pattern": "^[0]|([1-9][0-9]*)$",
+                  "type": "number"
+                },
+                "hash": {
+                  "description": "The calculated hash of the data using SHA-1. Represented using base64.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "title": {
+                  "description": "A label or set of text to display in place of the data.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "creation": {
+                  "description": "The date that the attachment was first created.",
+                  "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"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            },
+            "resource": {
+              "description": "The related resource, such as a library, value set, profile, or other knowledge resource.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        },
+        "valueUsageContext": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "code": {
+              "description": "A code that identifies the type of context being specified by this usage context.",
+              "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.",
+                  "widget": {
+                    "id": "hidden"
+                  },
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "system": {
+                  "description": "The identification of the code system that defines the meaning of the symbol in the code.",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "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.",
+                  "widget": {
+                    "id": "hidden"
+                  },
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "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).",
+                  "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                  "type": "string"
+                },
+                "display": {
+                  "description": "A representation of the meaning of the code in the system, following the rules of the system.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "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).",
+                  "pattern": "^true|false$",
+                  "type": "boolean"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object",
+              "widget": {
+                "id": "row-layout"
+              },
+              "fieldsets": [
+                {
+                  "fields": [
+                    "id",
+                    "system",
+                    "version",
+                    "code",
+                    "display",
+                    "userSelected"
+                  ],
+                  "showFields": [
+                    {
+                      "code": {
+                        "col": 2
+                      }
+                    },
+                    {
+                      "system": {
+                        "col": 6
+                      }
+                    },
+                    {
+                      "display": {
+                        "col": 4
+                      }
+                    }
+                  ]
+                }
+              ]
+            },
+            "valueCodeableConcept": {
+              "description": "A value that defines the context specified in this context of use. The interpretation of the value is defined by the code.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "coding": {
+                  "description": "A reference to a code defined by a terminology system.",
+                  "items": {
+                    "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.",
+                        "widget": {
+                          "id": "hidden"
+                        },
+                        "pattern": "^[ \\r\\n\\t\\S]+$",
+                        "type": "string"
+                      },
+                      "system": {
+                        "description": "The identification of the code system that defines the meaning of the symbol in the code.",
+                        "pattern": "^\\S*$",
+                        "type": "string"
+                      },
+                      "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.",
+                        "widget": {
+                          "id": "hidden"
+                        },
+                        "pattern": "^[ \\r\\n\\t\\S]+$",
+                        "type": "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).",
+                        "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                        "type": "string"
+                      },
+                      "display": {
+                        "description": "A representation of the meaning of the code in the system, following the rules of the system.",
+                        "pattern": "^[ \\r\\n\\t\\S]+$",
+                        "type": "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).",
+                        "pattern": "^true|false$",
+                        "type": "boolean"
+                      }
+                    },
+                    "additionalProperties": false,
+                    "type": "object",
+                    "widget": {
+                      "id": "row-layout"
+                    },
+                    "fieldsets": [
+                      {
+                        "fields": [
+                          "id",
+                          "system",
+                          "version",
+                          "code",
+                          "display",
+                          "userSelected"
+                        ],
+                        "showFields": [
+                          {
+                            "code": {
+                              "col": 2
+                            }
+                          },
+                          {
+                            "system": {
+                              "col": 6
+                            }
+                          },
+                          {
+                            "display": {
+                              "col": 4
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  },
+                  "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            },
+            "valueQuantity": {
+              "description": "A value that defines the context specified in this context of use. The interpretation of the value is defined by the code.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "value": {
+                  "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+                  "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+                  "type": "number"
+                },
+                "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": [
+                    "<",
+                    "<=",
+                    ">=",
+                    ">"
+                  ],
+                  "type": "string"
+                },
+                "unit": {
+                  "description": "A human-readable form of the unit.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "system": {
+                  "description": "The identification of the system that provides the coded form of the unit.",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "code": {
+                  "description": "A computer processable form of the unit in some unit representation system.",
+                  "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            },
+            "valueRange": {
+              "description": "A value that defines the context specified in this context of use. The interpretation of the value is defined by the code.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "low": {
+                  "description": "The low limit. The boundary is inclusive.",
+                  "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.",
+                      "pattern": "^[ \\r\\n\\t\\S]+$",
+                      "type": "string"
+                    },
+                    "value": {
+                      "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+                      "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+                      "type": "number"
+                    },
+                    "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": [
+                        "<",
+                        "<=",
+                        ">=",
+                        ">"
+                      ],
+                      "type": "string"
+                    },
+                    "unit": {
+                      "description": "A human-readable form of the unit.",
+                      "pattern": "^[ \\r\\n\\t\\S]+$",
+                      "type": "string"
+                    },
+                    "system": {
+                      "description": "The identification of the system that provides the coded form of the unit.",
+                      "pattern": "^\\S*$",
+                      "type": "string"
+                    },
+                    "code": {
+                      "description": "A computer processable form of the unit in some unit representation system.",
+                      "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                      "type": "string"
+                    }
+                  },
+                  "additionalProperties": false,
+                  "type": "object"
+                },
+                "high": {
+                  "description": "The high limit. The boundary is inclusive.",
+                  "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.",
+                      "pattern": "^[ \\r\\n\\t\\S]+$",
+                      "type": "string"
+                    },
+                    "value": {
+                      "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+                      "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+                      "type": "number"
+                    },
+                    "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": [
+                        "<",
+                        "<=",
+                        ">=",
+                        ">"
+                      ],
+                      "type": "string"
+                    },
+                    "unit": {
+                      "description": "A human-readable form of the unit.",
+                      "pattern": "^[ \\r\\n\\t\\S]+$",
+                      "type": "string"
+                    },
+                    "system": {
+                      "description": "The identification of the system that provides the coded form of the unit.",
+                      "pattern": "^\\S*$",
+                      "type": "string"
+                    },
+                    "code": {
+                      "description": "A computer processable form of the unit in some unit representation system.",
+                      "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                      "type": "string"
+                    }
+                  },
+                  "additionalProperties": false,
+                  "type": "object"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            },
+            "valueReference": {
+              "description": "A value that defines the context specified in this context of use. The interpretation of the value is defined by the code.",
+              "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                },
+                "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.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "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).",
+                  "pattern": "^\\S*$",
+                  "type": "string"
+                },
+                "display": {
+                  "description": "Plain text narrative that identifies the resource in addition to the resource reference.",
+                  "pattern": "^[ \\r\\n\\t\\S]+$",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "type": "object"
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "code"
+          ],
+          "type": "object"
+        },
+        "valueMeta": {
+          "description": "Value of extension - must be one of a constrained set of the data types (see [Extensibility](extensibility.html) for a list).",
+          "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.",
+              "pattern": "^[ \\r\\n\\t\\S]+$",
+              "type": "string"
+            },
+            "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.",
+              "pattern": "^[A-Za-z0-9\\-\\.]{1,64}$",
+              "type": "string"
+            },
+            "lastUpdated": {
+              "description": "When the resource last changed - e.g. when the version changed.",
+              "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"
+            },
+            "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.",
+              "pattern": "^\\S*$",
+              "type": "string"
+            },
+            "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": {
+                "pattern": "^\\S*$",
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "security": {
+              "description": "Security labels applied to this resource. These tags connect specific resources to the overall security policy and infrastructure.",
+              "items": {
+                "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.",
+                    "widget": {
+                      "id": "hidden"
+                    },
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "string"
+                  },
+                  "system": {
+                    "description": "The identification of the code system that defines the meaning of the symbol in the code.",
+                    "pattern": "^\\S*$",
+                    "type": "string"
+                  },
+                  "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.",
+                    "widget": {
+                      "id": "hidden"
+                    },
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "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).",
+                    "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                    "type": "string"
+                  },
+                  "display": {
+                    "description": "A representation of the meaning of the code in the system, following the rules of the system.",
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "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).",
+                    "pattern": "^true|false$",
+                    "type": "boolean"
+                  }
+                },
+                "additionalProperties": false,
+                "type": "object",
+                "widget": {
+                  "id": "row-layout"
+                },
+                "fieldsets": [
+                  {
+                    "fields": [
+                      "id",
+                      "system",
+                      "version",
+                      "code",
+                      "display",
+                      "userSelected"
+                    ],
+                    "showFields": [
+                      {
+                        "code": {
+                          "col": 2
+                        }
+                      },
+                      {
+                        "system": {
+                          "col": 6
+                        }
+                      },
+                      {
+                        "display": {
+                          "col": 4
+                        }
+                      }
+                    ]
+                  }
+                ]
+              },
+              "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": {
+                "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.",
+                    "widget": {
+                      "id": "hidden"
+                    },
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "string"
+                  },
+                  "system": {
+                    "description": "The identification of the code system that defines the meaning of the symbol in the code.",
+                    "pattern": "^\\S*$",
+                    "type": "string"
+                  },
+                  "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.",
+                    "widget": {
+                      "id": "hidden"
+                    },
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "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).",
+                    "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+                    "type": "string"
+                  },
+                  "display": {
+                    "description": "A representation of the meaning of the code in the system, following the rules of the system.",
+                    "pattern": "^[ \\r\\n\\t\\S]+$",
+                    "type": "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).",
+                    "pattern": "^true|false$",
+                    "type": "boolean"
+                  }
+                },
+                "additionalProperties": false,
+                "type": "object",
+                "widget": {
+                  "id": "row-layout"
+                },
+                "fieldsets": [
+                  {
+                    "fields": [
+                      "id",
+                      "system",
+                      "version",
+                      "code",
+                      "display",
+                      "userSelected"
+                    ],
+                    "showFields": [
+                      {
+                        "code": {
+                          "col": 2
+                        }
+                      },
+                      {
+                        "system": {
+                          "col": 6
+                        }
+                      },
+                      {
+                        "display": {
+                          "col": 4
+                        }
+                      }
+                    ]
+                  }
+                ]
+              },
+              "type": "array"
+            }
+          },
+          "additionalProperties": false,
+          "type": "object"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "widget": {
+        "id": "hidden"
+      }
+    },
+    "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"
+    },
+    "uri": {
+      "pattern": "^\\S*$",
+      "type": "string"
+    },
+    "canonical": {
+      "pattern": "^\\S*$",
+      "type": "string"
+    },
+    "Coding": {
+      "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.",
+          "widget": {
+            "id": "hidden"
+          },
+          "pattern": "^[ \\r\\n\\t\\S]+$",
+          "type": "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",
+          "widget": {
+            "id": "hidden"
+          }
+        },
+        "system": {
+          "description": "The identification of the code system that defines the meaning of the symbol in the code.",
+          "pattern": "^\\S*$",
+          "type": "string"
+        },
+        "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.",
+          "widget": {
+            "id": "hidden"
+          },
+          "pattern": "^[ \\r\\n\\t\\S]+$",
+          "type": "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).",
+          "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+          "type": "string"
+        },
+        "display": {
+          "description": "A representation of the meaning of the code in the system, following the rules of the system.",
+          "pattern": "^[ \\r\\n\\t\\S]+$",
+          "type": "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).",
+          "pattern": "^true|false$",
+          "type": "boolean"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "widget": {
+        "id": "grid"
+      },
+      "fieldsets": [
+        {
+          "fields": [
+            "id",
+            "extension",
+            "code",
+            "system",
+            "display",
+            "version",
+            "userSelected"
+          ],
+          "showFields": [
+            {
+              "field": "code",
+              "col": 2
+            },
+            {
+              "field": "system",
+              "col": 5
+            },
+            {
+              "field": "display",
+              "col": 5
+            }
+          ]
+        }
+      ]
+    },
+    "Element": {
+      "type": "object",
+      "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
+    },
+    "code": {
+      "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+      "type": "string"
+    },
+    "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"
+          ],
+          "type": "string"
+        },
+        "_status": {
+          "description": "Extensions for status",
+          "$ref": "#/definitions/Element"
+        },
+        "div": {
+          "description": "The actual narrative content, a stripped down version of XHTML.",
+          "$ref": "#/definitions/xhtml"
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "div"
+      ],
+      "type": "object"
+    },
+    "xhtml": {
+      "$ref": "#/definitions/string"
+    },
+    "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",
+          "widget": {
+            "id": "hidden"
+          }
+        },
+        "use": {
+          "description": "The purpose of this identifier.",
+          "enum": [
+            "usual",
+            "official",
+            "temp",
+            "secondary",
+            "old"
+          ],
+          "type": "string"
+        },
+        "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,
+      "type": "object"
+    },
+    "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",
+          "widget": {
+            "id": "hidden"
+          }
+        },
+        "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,
+      "type": "object"
+    },
+    "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",
+          "widget": {
+            "id": "hidden"
+          }
+        },
+        "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,
+      "type": "object"
+    },
+    "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"
+    },
+    "Reference": {
+      "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.",
+          "pattern": "^[ \\r\\n\\t\\S]+$",
+          "type": "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",
+          "widget": {
+            "id": "hidden"
+          }
+        },
+        "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.",
+          "pattern": "^[ \\r\\n\\t\\S]+$",
+          "type": "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).",
+          "pattern": "^\\S*$",
+          "type": "string"
+        },
+        "display": {
+          "description": "Plain text narrative that identifies the resource in addition to the resource reference.",
+          "pattern": "^[ \\r\\n\\t\\S]+$",
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object"
+    },
+    "boolean": {
+      "pattern": "^true|false$",
+      "type": "boolean"
+    },
+    "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",
+          "widget": {
+            "id": "hidden"
+          }
+        },
+        "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,
+      "type": "object"
+    },
+    "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",
+          "widget": {
+            "id": "hidden"
+          }
+        },
+        "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"
+          ],
+          "type": "string"
+        },
+        "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"
+          ],
+          "type": "string"
+        },
+        "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,
+      "type": "object"
+    },
+    "positiveInt": {
+      "pattern": "^[1-9][0-9]*$",
+      "type": "integer",
+      "minimum": 0,
+      "description": "An integer with a value that is positive (e.g. >0)"
+    },
+    "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"
+    },
+    "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",
+          "widget": {
+            "id": "hidden"
+          }
+        },
+        "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"
+      ],
+      "type": "object"
+    },
+    "Quantity": {
+      "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.",
+          "pattern": "^[ \\r\\n\\t\\S]+$",
+          "type": "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",
+          "widget": {
+            "id": "hidden"
+          }
+        },
+        "value": {
+          "description": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
+          "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+          "type": "number"
+        },
+        "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": [
+            "<",
+            "<=",
+            ">=",
+            ">"
+          ],
+          "type": "string"
+        },
+        "unit": {
+          "description": "A human-readable form of the unit.",
+          "pattern": "^[ \\r\\n\\t\\S]+$",
+          "type": "string"
+        },
+        "system": {
+          "description": "The identification of the system that provides the coded form of the unit.",
+          "pattern": "^\\S*$",
+          "type": "string"
+        },
+        "code": {
+          "description": "A computer processable form of the unit in some unit representation system.",
+          "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object"
+    },
+    "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",
+          "widget": {
+            "id": "hidden"
+          }
+        },
+        "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,
+      "type": "object"
+    },
+    "ValueSet_Compose": {
+      "description": "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).",
+      "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"
+        },
+        "lockedDate": {
+          "description": "The Locked Date is  the effective date that is used to determine the version of all referenced Code Systems and Value Set Definitions included in the compose that are not already tied to a specific version.",
+          "$ref": "#/definitions/date"
+        },
+        "_lockedDate": {
+          "description": "Extensions for lockedDate",
+          "$ref": "#/definitions/Element"
+        },
+        "inactive": {
+          "description": "Whether inactive codes - codes that are not approved for current use - are in the value set. If inactive = true, inactive codes are to be included in the expansion, if inactive = false, the inactive codes will not be included in the expansion. If absent, the behavior is determined by the implementation, or by the applicable $expand parameters (but generally, inactive codes would be expected to be included).",
+          "$ref": "#/definitions/boolean"
+        },
+        "_inactive": {
+          "description": "Extensions for inactive",
+          "$ref": "#/definitions/Element"
+        },
+        "include": {
+          "description": "Include one or more codes from a code system or other value set(s).",
+          "items": {
+            "$ref": "#/definitions/ValueSet_Include"
+          },
+          "type": "array"
+        },
+        "exclude": {
+          "description": "Exclude one or more codes from the value set based on code system filters and/or other value sets.",
+          "items": {
+            "$ref": "#/definitions/ValueSet_Include"
+          },
+          "type": "array"
+        }
+      },
+      "additionalProperties": false,
+      "required": [
+        "include"
+      ],
+      "type": "object"
+    },
+    "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."
+    },
+    "ValueSet_Include": {
+      "description": "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).",
+      "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"
+        },
+        "system": {
+          "description": "An absolute URI which is the code system from which the selected codes come from.",
+          "$ref": "#/definitions/uri"
+        },
+        "_system": {
+          "description": "Extensions for system",
+          "$ref": "#/definitions/Element"
+        },
+        "version": {
+          "description": "The version of the code system that the codes are selected from, or the special version '*' for all versions.",
+          "$ref": "#/definitions/string"
+        },
+        "_version": {
+          "description": "Extensions for version",
+          "$ref": "#/definitions/Element"
+        },
+        "concept": {
+          "description": "Specifies a concept to be included or excluded.",
+          "items": {
+            "$ref": "#/definitions/ValueSet_Concept"
+          },
+          "type": "array"
+        },
+        "filter": {
+          "description": "Select concepts by specify a matching criterion based on the properties (including relationships) defined by the system, or on filters defined by the system. If multiple filters are specified, they SHALL all be true.",
+          "items": {
+            "$ref": "#/definitions/ValueSet_Filter"
+          },
+          "type": "array"
+        },
+        "valueSet": {
+          "description": "Selects the concepts found in this value set (based on its value set definition). This is an absolute URI that is a reference to ValueSet.url.  If multiple value sets are specified this includes the union of the contents of all of the referenced value sets.",
+          "items": {
+            "$ref": "#/definitions/canonical"
+          },
+          "type": "array"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object"
+    },
+    "ValueSet_Concept": {
+      "description": "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).",
+      "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": "Specifies a code for the concept to be included or excluded.",
+          "$ref": "#/definitions/code"
+        },
+        "_code": {
+          "description": "Extensions for code",
+          "$ref": "#/definitions/Element"
+        },
+        "display": {
+          "description": "The text to display to the user for this concept in the context of this valueset. If no display is provided, then applications using the value set use the display specified for the code by the system.",
+          "$ref": "#/definitions/string"
+        },
+        "_display": {
+          "description": "Extensions for display",
+          "$ref": "#/definitions/Element"
+        },
+        "designation": {
+          "description": "Additional representations for this concept when used in this value set - other languages, aliases, specialized purposes, used for particular purposes, etc.",
+          "items": {
+            "$ref": "#/definitions/ValueSet_Designation"
+          },
+          "type": "array"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object"
+    },
+    "ValueSet_Designation": {
+      "description": "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).",
+      "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 language this designation is defined for.",
+          "$ref": "#/definitions/code"
+        },
+        "_language": {
+          "description": "Extensions for language",
+          "$ref": "#/definitions/Element"
+        },
+        "use": {
+          "description": "A code that represents types of uses of designations.",
+          "$ref": "#/definitions/Coding"
+        },
+        "value": {
+          "description": "The text value for this designation.",
+          "$ref": "#/definitions/string"
+        },
+        "_value": {
+          "description": "Extensions for value",
+          "$ref": "#/definitions/Element"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object"
+    },
+    "ValueSet_Filter": {
+      "description": "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).",
+      "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"
+        },
+        "property": {
+          "description": "A code that identifies a property or a filter defined in the code system.",
+          "$ref": "#/definitions/code"
+        },
+        "_property": {
+          "description": "Extensions for property",
+          "$ref": "#/definitions/Element"
+        },
+        "op": {
+          "description": "The kind of operation to perform as a part of the filter criteria.",
+          "enum": [
+            "=",
+            "is-a",
+            "descendent-of",
+            "is-not-a",
+            "regex",
+            "in",
+            "not-in",
+            "generalizes",
+            "exists"
+          ],
+          "type": "string"
+        },
+        "_op": {
+          "description": "Extensions for op",
+          "$ref": "#/definitions/Element"
+        },
+        "value": {
+          "description": "The match value may be either a code defined by the system, or a string value, which is a regex match on the literal string of the property value  (if the filter represents a property defined in CodeSystem) or of the system filter value (if the filter represents a filter defined in CodeSystem) when the operation is 'regex', or one of the values (true and false), when the operation is 'exists'.",
+          "$ref": "#/definitions/string"
+        },
+        "_value": {
+          "description": "Extensions for value",
+          "$ref": "#/definitions/Element"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object"
+    },
+    "ValueSet_Expansion": {
+      "description": "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).",
+      "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 uniquely identifies this expansion of the valueset, based on a unique combination of the provided parameters, the system default parameters, and the underlying system code system versions etc. Systems may re-use the same identifier as long as those factors remain the same, and the expansion is the same, but are not required to do so. This is a business identifier.",
+          "$ref": "#/definitions/uri"
+        },
+        "_identifier": {
+          "description": "Extensions for identifier",
+          "$ref": "#/definitions/Element"
+        },
+        "timestamp": {
+          "description": "The time at which the expansion was produced by the expanding system.",
+          "$ref": "#/definitions/dateTime"
+        },
+        "_timestamp": {
+          "description": "Extensions for timestamp",
+          "$ref": "#/definitions/Element"
+        },
+        "total": {
+          "description": "The total number of concepts in the expansion. If the number of concept nodes in this resource is less than the stated number, then the server can return more using the offset parameter.",
+          "$ref": "#/definitions/integer"
+        },
+        "_total": {
+          "description": "Extensions for total",
+          "$ref": "#/definitions/Element"
+        },
+        "offset": {
+          "description": "If paging is being used, the offset at which this resource starts.  I.e. this resource is a partial view into the expansion. If paging is not being used, this element SHALL NOT be present.",
+          "$ref": "#/definitions/integer"
+        },
+        "_offset": {
+          "description": "Extensions for offset",
+          "$ref": "#/definitions/Element"
+        },
+        "parameter": {
+          "description": "A parameter that controlled the expansion process. These parameters may be used by users of expanded value sets to check whether the expansion is suitable for a particular purpose, or to pick the correct expansion.",
+          "items": {
+            "$ref": "#/definitions/ValueSet_Parameter"
+          },
+          "type": "array"
+        },
+        "contains": {
+          "description": "The codes that are contained in the value set expansion.",
+          "items": {
+            "$ref": "#/definitions/ValueSet_Contains"
+          },
+          "type": "array"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object"
+    },
+    "integer": {
+      "pattern": "^-?([0]|([1-9][0-9]*))$",
+      "type": "integer"
+    },
+    "ValueSet_Parameter": {
+      "description": "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).",
+      "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": "Name of the input parameter to the $expand operation; may be a server-assigned name for additional default or other server-supplied parameters used to control the expansion process.",
+          "$ref": "#/definitions/string"
+        },
+        "_name": {
+          "description": "Extensions for name",
+          "$ref": "#/definitions/Element"
+        },
+        "valueString": {
+          "description": "The value of the parameter.",
+          "pattern": "^[ \\r\\n\\t\\S]+$",
+          "type": "string"
+        },
+        "_valueString": {
+          "description": "Extensions for valueString",
+          "$ref": "#/definitions/Element"
+        },
+        "valueBoolean": {
+          "description": "The value of the parameter.",
+          "pattern": "^true|false$",
+          "type": "boolean"
+        },
+        "_valueBoolean": {
+          "description": "Extensions for valueBoolean",
+          "$ref": "#/definitions/Element"
+        },
+        "valueInteger": {
+          "description": "The value of the parameter.",
+          "pattern": "^-?([0]|([1-9][0-9]*))$",
+          "type": "number"
+        },
+        "_valueInteger": {
+          "description": "Extensions for valueInteger",
+          "$ref": "#/definitions/Element"
+        },
+        "valueDecimal": {
+          "description": "The value of the parameter.",
+          "pattern": "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$",
+          "type": "number"
+        },
+        "_valueDecimal": {
+          "description": "Extensions for valueDecimal",
+          "$ref": "#/definitions/Element"
+        },
+        "valueUri": {
+          "description": "The value of the parameter.",
+          "pattern": "^\\S*$",
+          "type": "string"
+        },
+        "_valueUri": {
+          "description": "Extensions for valueUri",
+          "$ref": "#/definitions/Element"
+        },
+        "valueCode": {
+          "description": "The value of the parameter.",
+          "pattern": "^[^\\s]+(\\s[^\\s]+)*$",
+          "type": "string"
+        },
+        "_valueCode": {
+          "description": "Extensions for valueCode",
+          "$ref": "#/definitions/Element"
+        },
+        "valueDateTime": {
+          "description": "The value of the parameter.",
+          "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"
+        },
+        "_valueDateTime": {
+          "description": "Extensions for valueDateTime",
+          "$ref": "#/definitions/Element"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object"
+    },
+    "ValueSet_Contains": {
+      "description": "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).",
+      "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"
+        },
+        "system": {
+          "description": "An absolute URI which is the code system in which the code for this item in the expansion is defined.",
+          "$ref": "#/definitions/uri"
+        },
+        "_system": {
+          "description": "Extensions for system",
+          "$ref": "#/definitions/Element"
+        },
+        "abstract": {
+          "description": "If true, this entry is included in the expansion for navigational purposes, and the user cannot select the code directly as a proper value.",
+          "$ref": "#/definitions/boolean"
+        },
+        "_abstract": {
+          "description": "Extensions for abstract",
+          "$ref": "#/definitions/Element"
+        },
+        "inactive": {
+          "description": "If the concept is inactive in the code system that defines it. Inactive codes are those that are no longer to be used, but are maintained by the code system for understanding legacy data. It might not be known or specified whether an concept is inactive (and it may depend on the context of use).",
+          "$ref": "#/definitions/boolean"
+        },
+        "_inactive": {
+          "description": "Extensions for inactive",
+          "$ref": "#/definitions/Element"
+        },
+        "version": {
+          "description": "The version of the code system from this code was taken. 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"
+        },
+        "_version": {
+          "description": "Extensions for version",
+          "$ref": "#/definitions/Element"
+        },
+        "code": {
+          "description": "The code for this item in the expansion hierarchy. If this code is missing the entry in the hierarchy is a place holder (abstract) and does not represent a valid code in the value set.",
+          "$ref": "#/definitions/code"
+        },
+        "_code": {
+          "description": "Extensions for code",
+          "$ref": "#/definitions/Element"
+        },
+        "display": {
+          "description": "The recommended display for this item in the expansion.",
+          "$ref": "#/definitions/string"
+        },
+        "_display": {
+          "description": "Extensions for display",
+          "$ref": "#/definitions/Element"
+        },
+        "designation": {
+          "description": "Additional representations for this item - other languages, aliases, specialized purposes, used for particular purposes, etc. These are relevant when the conditions of the expansion do not fix to a single correct representation.",
+          "items": {
+            "$ref": "#/definitions/ValueSet_Designation"
+          },
+          "type": "array"
+        },
+        "contains": {
+          "description": "Other codes and entries contained under this entry in the hierarchy.",
+          "items": {
+            "$ref": "#/definitions/ValueSet_Contains"
+          },
+          "type": "array"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object"
+    }
+  }
+}