import { Extension } from './Extension.js';
import { FhirPrimitive } from './FhirPrimitive.js';
import { OperationDefinition_Parameter_Binding } from './OperationDefinition_Parameter_Binding.js';
import { OperationDefinition_Parameter_ReferencedFrom } from './OperationDefinition_Parameter_ReferencedFrom.js';
export interface OperationDefinition_Parameter {
    /**
     * @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 The name of used to identify the parameter.
     * @comment This name must be a token (start with a letter in a..z, and only contain letters, numerals, and underscore. Note that for search parameters (type = string, with a search type), the name may be altered by the search modifiers.
     * @short Name in Parameters.parameter.name or in URL
     */
    name: FhirPrimitive<string>;
    /**
     * @description Whether this is an input or an output parameter.
     * @comment If a parameter name is used for both an input and an output parameter, the parameter should be defined twice.
     * @short in | out
     */
    use: FhirPrimitive<string>;
    /**
     * @description If present, indicates that the parameter applies when the operation is being invoked at the specified level.
     * @short instance | type | system
     */
    scope?: FhirPrimitive<string>[];
    /**
     * @description The minimum number of times this parameter SHALL appear in the request or response.
     * @short Minimum Cardinality
     */
    min: FhirPrimitive<number>;
    /**
     * @description The maximum number of times this element is permitted to appear in the request or response.
     * @short Maximum Cardinality (a number or )
     */
    max: FhirPrimitive<string>;
    /**
     * @description Describes the meaning or use of this parameter.
     * @short Description of meaninguse
     */
    documentation?: FhirPrimitive<string>;
    /**
     * @description The type for this parameter.
     * @comment if there is no stated parameter, then the parameter is a multi-part parameter type and must have at least one part defined.
     * @short What type this parameter has
     */
    type?: FhirPrimitive<string>;
    /**
     * @description Support for polymorphic types. If the parameter type is abstract, this element lists allowed sub-types for the parameter.
     * @comment In previous versions of FHIR, there was an extension for this: http:hl7.orgfhirStructureDefinitionoperationdefinition-allowed-type
     * @short Allowed sub-type this parameter can have (if type is abstract)
     */
    allowedType?: FhirPrimitive<string>[];
    /**
     * @description Used when the type is "Reference" or "canonical", and identifies a profile structure or implementation Guide that applies to the target of the reference this parameter refers to. If any profiles are specified, then the content must conform to at least one of them. The URL can be a local reference - to a contained StructureDefinition, or a reference to another StructureDefinition or Implementation Guide by a canonical URL. When an implementation guide is specified, the target resource SHALL conform to at least one profile defined in the implementation guide.
     * @comment Often, these profiles are the base definitions from the spec (e.g. http:hl7.orgfhirStructureDefinitionPatient).
     * @short If type is Reference | canonical, allowed targets. If type is 'Resource', then this constrains the allowed resource types
     */
    targetProfile?: FhirPrimitive<string>[];
    /**
     * @description How the parameter is understood ifwhen it used as search parameter. This is only used if the parameter is a string.
     * @comment Parameters that are search parameter usually - but not always - are also defined for use with general searches, and function in the operation to filter the set of resources in scope for the operation just like the do when searching. The searchType describes how the server processes the value. For an example, see the [Evaluate Measure Operation](measure-operation-evaluate-measure.html)
     * @short number | date | string | token | reference | composite | quantity | uri | special
     */
    searchType?: FhirPrimitive<string>;
    /**
     * @backbone Nested BackboneElement: binding [0..1]
     */
    binding?: OperationDefinition_Parameter_Binding;
    /**
     * @backbone Nested BackboneElement: referencedFrom [0..*]
     */
    referencedFrom?: OperationDefinition_Parameter_ReferencedFrom[];
    /**
     * @description The parts of a nested Parameter.
     * @comment Query Definitions only have one output parameter, named "result". This might not be described, but can be to allow a profile to be defined.
     * @short Parts of a nested Parameter
     */
    part?: any[];
}
//# sourceMappingURL=OperationDefinition_Parameter.d.ts.map