import { Extension } from './Extension.js';
import { FhirPrimitive } from './FhirPrimitive.js';
export interface Expression {
    /**
     * @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 A brief, natural language description of the condition that effectively communicates the intended semantics.
     * @short Natural language description of the condition
     */
    description?: FhirPrimitive<string>;
    /**
     * @description A short name assigned to the expression to allow for multiple reuse of the expression in the context where it is defined.
     * @short Short name assigned to expression for reuse
     */
    name?: FhirPrimitive<string>;
    /**
     * @description The media type of the language for the expression.
     * @short textcql | textfhirpath | applicationx-fhir-query | etc.
     */
    language?: FhirPrimitive<string>;
    /**
     * @description An expression in the specified language that returns a value.
     * @comment If Expression.expression and Expression.reference are both present, the Expression.expression might just be a name pointing something within the referenced content.
     * @short Expression in specified language
     */
    expression?: FhirPrimitive<string>;
    /**
     * @description A URI that defines where the expression is found.
     * @comment If both a reference and an expression is found, the reference SHALL point to the same expression.
     * @short Where the expression is found
     */
    reference?: FhirPrimitive<string>;
}
//# sourceMappingURL=Expression.d.ts.map