@medplum/fhirtypes/dist/ElementDefinition.d.ts

Medplum FHIR Type Definitions

/*
 * This is a generated file
 * Do not edit manually.
 */

import { Address } from './Address';
import { Age } from './Age';
import { Annotation } from './Annotation';
import { Attachment } from './Attachment';
import { CodeableConcept } from './CodeableConcept';
import { Coding } from './Coding';
import { ContactDetail } from './ContactDetail';
import { ContactPoint } from './ContactPoint';
import { Contributor } from './Contributor';
import { Count } from './Count';
import { DataRequirement } from './DataRequirement';
import { Distance } from './Distance';
import { Dosage } from './Dosage';
import { Duration } from './Duration';
import { Expression } from './Expression';
import { Extension } from './Extension';
import { HumanName } from './HumanName';
import { Identifier } from './Identifier';
import { Meta } from './Meta';
import { Money } from './Money';
import { ParameterDefinition } from './ParameterDefinition';
import { Period } from './Period';
import { Quantity } from './Quantity';
import { Range } from './Range';
import { Ratio } from './Ratio';
import { Reference } from './Reference';
import { RelatedArtifact } from './RelatedArtifact';
import { SampledData } from './SampledData';
import { Signature } from './Signature';
import { Timing } from './Timing';
import { TriggerDefinition } from './TriggerDefinition';
import { UsageContext } from './UsageContext';

/**
 * Captures constraints on each element within the resource, profile, or
 * extension.
 */
export interface ElementDefinition {

  /**
   * Unique id for the element within a resource (for internal references).
   * This may be any string value that does not contain spaces.
   */
  id?: string;

  /**
   * May be used to represent additional information that is not part of
   * the basic definition of the element. To make the use of extensions
   * safe and manageable, there is a strict set of governance  applied to
   * the definition and use of extensions. Though any implementer can
   * define an extension, there is a set of requirements that SHALL be met
   * as part of the definition of the extension.
   */
  extension?: Extension[];

  /**
   * May be used to represent additional information that is not part of
   * the basic definition of the element and that modifies the
   * understanding of the element in which it is contained and/or the
   * understanding of the containing element's descendants. Usually
   * modifier elements provide negation or qualification. To make the use
   * of extensions safe and manageable, there is a strict set of governance
   * applied to the definition and use of extensions. Though any
   * implementer can define an extension, there is a set of requirements
   * that SHALL be met as part of the definition of the extension.
   * Applications processing a resource are required to check for modifier
   * extensions.
   *
   * Modifier extensions SHALL NOT change the meaning of any elements on
   * Resource or DomainResource (including cannot change the meaning of
   * modifierExtension itself).
   */
  modifierExtension?: Extension[];

  /**
   * The path identifies the element and is expressed as a "."-separated
   * list of ancestor elements, beginning with the name of the resource or
   * extension.
   */
  path: string;

  /**
   * Codes that define how this element is represented in instances, when
   * the deviation varies from the normal case.
   */
  representation?: ('xmlAttr' | 'xmlText' | 'typeAttr' | 'cdaText' | 'xhtml')[];

  /**
   * The name of this element definition slice, when slicing is working.
   * The name must be a token with no dots or spaces. This is a unique name
   * referring to a specific set of constraints applied to this element,
   * used to provide a name to different slices of the same element.
   */
  sliceName?: string;

  /**
   * If true, indicates that this slice definition is constraining a slice
   * definition with the same name in an inherited profile. If false, the
   * slice is not overriding any slice in an inherited profile. If missing,
   * the slice might or might not be overriding a slice in an inherited
   * profile, depending on the sliceName.
   */
  sliceIsConstraining?: boolean;

  /**
   * A single preferred label which is the text to display beside the
   * element indicating its meaning or to use to prompt for the element in
   * a user display or form.
   */
  label?: string;

  /**
   * A code that has the same meaning as the element in a particular
   * terminology.
   */
  code?: Coding[];

  /**
   * Indicates that the element is sliced into a set of alternative
   * definitions (i.e. in a structure definition, there are multiple
   * different constraints on a single element in the base resource).
   * Slicing can be used in any resource that has cardinality ..* on the
   * base resource, or any resource with a choice of types. The set of
   * slices is any elements that come after this in the element sequence
   * that have the same path, until a shorter path occurs (the shorter path
   * terminates the set).
   */
  slicing?: ElementDefinitionSlicing;

  /**
   * A concise description of what this element means (e.g. for use in
   * autogenerated summaries).
   */
  short?: string;

  /**
   * Provides a complete explanation of the meaning of the data element for
   * human readability.  For the case of elements derived from existing
   * elements (e.g. constraints), the definition SHALL be consistent with
   * the base definition, but convey the meaning of the element in the
   * particular context of use of the resource. (Note: The text you are
   * reading is specified in ElementDefinition.definition).
   */
  definition?: string;

  /**
   * Explanatory notes and implementation guidance about the data element,
   * including notes about how to use the data properly, exceptions to
   * proper use, etc. (Note: The text you are reading is specified in
   * ElementDefinition.comment).
   */
  comment?: string;

  /**
   * This element is for traceability of why the element was created and
   * why the constraints exist as they do. This may be used to point to
   * source materials or specifications that drove the structure of this
   * element.
   */
  requirements?: string;

  /**
   * Identifies additional names by which this element might also be known.
   */
  alias?: string[];

  /**
   * The minimum number of times this element SHALL appear in the instance.
   */
  min?: number;

  /**
   * The maximum number of times this element is permitted to appear in the
   * instance.
   */
  max?: string;

  /**
   * Information about the base definition of the element, provided to make
   * it unnecessary for tools to trace the deviation of the element through
   * the derived and related profiles. When the element definition is not
   * the original definition of an element - i.g. either in a constraint on
   * another type, or for elements from a super type in a snap shot - then
   * the information in provided in the element definition may be different
   * to the base definition. On the original definition of the element, it
   * will be same.
   */
  base?: ElementDefinitionBase;

  /**
   * Identifies an element defined elsewhere in the definition whose
   * content rules should be applied to the current element.
   * ContentReferences bring across all the rules that are in the
   * ElementDefinition for the element, including definitions, cardinality
   * constraints, bindings, invariants etc.
   */
  contentReference?: string;

  /**
   * The data type or resource that the value of this element is permitted
   * to be.
   */
  type?: ElementDefinitionType[];

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueBase64Binary?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueBoolean?: boolean;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueCanonical?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueCode?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueDate?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueDateTime?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueDecimal?: number;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueId?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueInstant?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueInteger?: number;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueMarkdown?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueOid?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValuePositiveInt?: number;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueString?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueTime?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueUnsignedInt?: number;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueUri?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueUrl?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueUuid?: string;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueAddress?: Address;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueAge?: Age;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueAnnotation?: Annotation;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueAttachment?: Attachment;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueCodeableConcept?: CodeableConcept;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueCoding?: Coding;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueContactPoint?: ContactPoint;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueCount?: Count;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueDistance?: Distance;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueDuration?: Duration;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueHumanName?: HumanName;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueIdentifier?: Identifier;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueMoney?: Money;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValuePeriod?: Period;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueQuantity?: Quantity;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueRange?: Range;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueRatio?: Ratio;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueReference?: Reference;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueSampledData?: SampledData;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueSignature?: Signature;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueTiming?: Timing;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueContactDetail?: ContactDetail;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueContributor?: Contributor;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueDataRequirement?: DataRequirement;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueExpression?: Expression;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueParameterDefinition?: ParameterDefinition;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueRelatedArtifact?: RelatedArtifact;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueTriggerDefinition?: TriggerDefinition;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueUsageContext?: UsageContext;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueDosage?: Dosage;

  /**
   * The value that should be used if there is no value stated in the
   * instance (e.g. 'if not otherwise specified, the abstract is false').
   */
  defaultValueMeta?: Meta;

  /**
   * The Implicit meaning that is to be understood when this element is
   * missing (e.g. 'when this element is missing, the period is ongoing').
   */
  meaningWhenMissing?: string;

  /**
   * If present, indicates that the order of the repeating element has
   * meaning and describes what that meaning is.  If absent, it means that
   * the order of the element has no meaning.
   */
  orderMeaning?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedBase64Binary?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedBoolean?: boolean;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedCanonical?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedCode?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedDate?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedDateTime?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedDecimal?: number;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedId?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedInstant?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedInteger?: number;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedMarkdown?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedOid?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedPositiveInt?: number;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedString?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedTime?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedUnsignedInt?: number;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedUri?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedUrl?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedUuid?: string;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedAddress?: Address;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedAge?: Age;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedAnnotation?: Annotation;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedAttachment?: Attachment;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedCodeableConcept?: CodeableConcept;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedCoding?: Coding;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedContactPoint?: ContactPoint;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedCount?: Count;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedDistance?: Distance;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedDuration?: Duration;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedHumanName?: HumanName;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedIdentifier?: Identifier;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedMoney?: Money;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedPeriod?: Period;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedQuantity?: Quantity;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedRange?: Range;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedRatio?: Ratio;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedReference?: Reference;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedSampledData?: SampledData;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedSignature?: Signature;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedTiming?: Timing;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedContactDetail?: ContactDetail;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedContributor?: Contributor;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedDataRequirement?: DataRequirement;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedExpression?: Expression;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedParameterDefinition?: ParameterDefinition;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedRelatedArtifact?: RelatedArtifact;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedTriggerDefinition?: TriggerDefinition;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedUsageContext?: UsageContext;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedDosage?: Dosage;

  /**
   * Specifies a value that SHALL be exactly the value  for this element in
   * the instance. For purposes of comparison, non-significant whitespace
   * is ignored, and all values must be an exact match (case and accent
   * sensitive). Missing elements/attributes must also be missing.
   */
  fixedMeta?: Meta;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternBase64Binary?: string;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternBoolean?: boolean;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternCanonical?: string;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternCode?: string;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternDate?: string;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternDateTime?: string;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternDecimal?: number;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternId?: string;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternInstant?: string;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternInteger?: number;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternMarkdown?: string;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternOid?: string;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternPositiveInt?: number;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternString?: string;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, any value in the pattern must be found in the instance. Other
   * additional values may be found too. This is effectively constraint by
   * example.
   *
   * When pattern[x] is used to constrain a primitive, it means that the
   * value provided in the pattern[x] must match the instance value
   * exactly.
   *
   * When pattern[x] is used to constrain an array, it means that each
   * element provided in the pattern[x] array must (recursively) match at
   * least one element from the instance array.
   *
   * When pattern[x] is used to constrain a complex object, it means that
   * each property in the pattern must be present in the complex object,
   * and its value must recursively match -- i.e.,
   *
   * 1. If primitive: it must match exactly the pattern value
   * 2. If a complex object: it must match (recursively) the pattern value
   * 3. If an array: it must match (recursively) the pattern value.
   */
  patternTime?: string;

  /**
   * Specifies a value that the value in the instance SHALL follow - that
   * is, a