import { Coding } from './Coding.js';
import { Extension } from './Extension.js';
import { FhirPrimitive } from './FhirPrimitive.js';
import { Questionnaire_Item_AnswerOption } from './Questionnaire_Item_AnswerOption.js';
import { Questionnaire_Item_EnableWhen } from './Questionnaire_Item_EnableWhen.js';
import { Questionnaire_Item_Initial } from './Questionnaire_Item_Initial.js';
export interface Questionnaire_Item {
    /**
     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
     * @short Unique id for inter-element referencing
     */
    id?: string;
    /**
     * @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 managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
     * @short Additional content defined by implementations
     */
    extension?: Extension[];
    /**
     * @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 andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though 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).
     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
     * @short Extensions that cannot be ignored even if unrecognized
     */
    modifierExtension?: Extension[];
    /**
     * @description An identifier that is unique within the Questionnaire allowing linkage to the equivalent item in a QuestionnaireResponse resource.
     * @comment This ''can'' be a meaningful identifier (e.g. a LOINC code) but is not intended to have any meaning.  GUIDs or sequential numbers are appropriate here.
  
  LinkIds can have whitespaces and slashes by design. Tooling should not rely on linkIds being valid XHTML element IDs, and should not directly embed them as such
     * @short Unique id for item in questionnaire
     */
    linkId: FhirPrimitive<string>;
    /**
     * @description This element is a URI that refers to an [ElementDefinition](elementdefinition.html) or to an [ObservationDefinition](observationdefinition.html) that provides information about this item, including information that might otherwise be included in the instance of the Questionnaire resource. A detailed description of the construction of the URI is shown in [Comments](questionnaire.html#definition), below.
     * @comment The uri refers to an ElementDefinition in a [StructureDefinition](structuredefinition.html#) or to an [ObservationDefinition](observationdefinition.html) and always starts with the [canonical URL](references.html#canonical) for the target resource. When referring to a StructureDefinition, a fragment identifier is used to specify the element definition by its id [Element.id](types-definitions.html#Element.id). E.g. http:hl7.orgfhirStructureDefinitionObservation#Observation.value[x]. In the absence of a fragment identifier, the firstroot element definition in the target is the matching element definition.
     * @short ElementDefinition - details for the item
     */
    definition?: FhirPrimitive<string>;
    /**
     * @description A terminology code that corresponds to this group or question (e.g. a code from LOINC, which defines many questions and answers).
     * @comment The value may come from the ElementDefinition referred to by .definition.
     * @short Corresponding concept for this item in a terminology
     */
    code?: Coding[];
    /**
     * @description A short label for a particular group, question or set of display text within the questionnaire used for reference by the individual completing the questionnaire.
     * @comment These are generally unique within a questionnaire, though this is not guaranteed. Some questionnaires may have multiple questions with the same label with logic to control which gets exposed.  Typically, these won't be used for "display" items, though such use is not prohibited.  Systems SHOULD NOT generate their own prefixes if prefixes are defined for any items within a Questionnaire.
     * @short E.g. "1(a)", "2.5.3"
     */
    prefix?: FhirPrimitive<string>;
    /**
     * @description The name of a section, the text of a question or text content for a display item.
     * @comment When using this element to represent the name of a section, use group type item and also make sure to limit the text element to a short string suitable for display as a section heading.  Group item instructions should be included as a display type item within the group.
     * @short Primary text for the item
     */
    text?: FhirPrimitive<string>;
    /**
     * @description The type of questionnaire item this is - whether text for display, a grouping of other items or a particular type of data to be captured (string, integer, Coding, etc.).
     * @comment Additional constraints on the type of answer can be conveyed by extensions. The value may come from the ElementDefinition referred to by .definition.
     * @short group | display | boolean | decimal | integer | date | dateTime +
     */
    type: FhirPrimitive<string>;
    /**
     * @backbone Nested BackboneElement: enableWhen [0..*]
     */
    enableWhen?: Questionnaire_Item_EnableWhen[];
    /**
     * @description Controls how multiple enableWhen values are interpreted -  whether all or any must be true.
     * @comment This element must be specified if more than one enableWhen value is provided.
     * @short all | any
     */
    enableBehavior?: FhirPrimitive<string>;
    /**
     * @description Indicates if and how items that are disabled (because enableWhen evaluates to 'false') should be displayed.
     * @comment If not specified, rendering behavior is up to the client.  This element is only meaningful if enableWhen or an equivalent extension is present
     * @short hidden | protected
     */
    disabledDisplay?: FhirPrimitive<string>;
    /**
     * @description An indication, if true, that the item must be present in a "completed" QuestionnaireResponse.  If false, the item may be skipped when answering the questionnaire.
     * @comment If the required item is a question, it must have a direct answer (i.e. an answer to the question itself, not merely answers to child questions) in order for the QuestionnaireResponse to be complete.  If the required item is a group, it must have at least one descendant question which has an answer  Questionnaire.item.required only has meaning for elements that are conditionally enabled with enableWhen if the condition evaluates to true.  It also only has meaning if the parent element is present.  If a non-required 'group' item contains a 'required' question item, it's completely fine to omit the group (because it's not required) despite it having a required child.  Similarly, if an item that contains other items is marked as required, that does not automatically make the contained elements required (though required groups must contain at least one descendant item with a populated answer). The value for 'required' may come from the ElementDefinition referred to by .definition.
     * @short Whether the item must be included in data results
     */
    required?: FhirPrimitive<boolean>;
    /**
     * @description An indication, if true, that a QuestionnaireResponse for this item may include multiple answers associated with a single instance of this item (for question-type items) or multiple repetitions of the item (for group-type items).
     * @comment If a question is marked as repeats=true, then multiple answers can be provided for the question in the corresponding QuestionnaireResponse.  When rendering the questionnaire, it is up to the rendering software whether to render the question text for each answer repetition (i.e. "repeat the question") or to simply allow entryselection of multiple answers for the question (repeat the answers).  Which is most appropriate visually may depend on the type of answer as well as whether there are nested items.
  
  The resulting QuestionnaireResponse will be populated the same way regardless of rendering - one 'question' item with multiple answer values.
  
   The value may come from the ElementDefinition referred to by .definition.  When repeats=true for a group, it'll be represented with multiple items with the same linkId in the QuestionnaireResponse.  For a question, it'll be represented by a single item with that linkId with multiple answers.
     * @short Whether the item may repeat
     */
    repeats?: FhirPrimitive<boolean>;
    /**
     * @description An indication, when true, that the value cannot be changed by a human respondent to the Questionnaire.
     * @comment If specified on a 'group', then all items beneath the specified group are read only.  For questions, this only marks the answer associated with the specific item read only.  Descendant questions are not impacted.  The value of readOnly elements can be established by asserting extensions for defaultValues, linkages that support pre-population andor extensions that support calculation based on other answers.
     * @short Don't allow human editing
     */
    readOnly?: FhirPrimitive<boolean>;
    /**
     * @description The maximum number of characters that are permitted in the answer to be considered a "valid" QuestionnaireResponse.
     * @comment For base64binary, reflects the number of characters representing the encoded data, not the number of bytes of the binary data. The value may come from the ElementDefinition referred to by .definition.
     * @short No more than these many characters
     */
    maxLength?: FhirPrimitive<number>;
    /**
     * @description For items that have a defined set of allowed answers (via answerOption or answerValueSet), indicates whether values other than those specified can be selected.
     * @short optionsOnly | optionsOrType | optionsOrString
     */
    answerConstraint?: FhirPrimitive<string>;
    /**
     * @description A reference to a value set containing a list of values representing permitted answers for a question.
     * @comment LOINC defines many useful value sets for questionnaire responses. See [LOINC Answer Lists](https:terminology.hl7.orgLOINC.html). The value may come from the ElementDefinition referred to by .definition.
     * @short ValueSet containing permitted answers
     */
    answerValueSet?: FhirPrimitive<string>;
    /**
     * @backbone Nested BackboneElement: answerOption [0..*]
     */
    answerOption?: Questionnaire_Item_AnswerOption[];
    /**
     * @backbone Nested BackboneElement: initial [0..*]
     */
    initial?: Questionnaire_Item_Initial[];
    /**
     * @description Text, questions and other groups to be nested beneath a question or group.
     * @comment There is no specified limit to the depth of nesting.  However, Questionnaire authors are encouraged to consider the impact on the user and user interface of overly deep nesting.
     * @short Nested questionnaire items
     */
    item?: any[];
}
//# sourceMappingURL=Questionnaire_Item.d.ts.map