type: resource-definitionsresource: Requirements

Requirements Definitions

Requirements

A set of requirements - features of systems that are necessary

Definition: A set of requirements - a list of features or behaviors of designed systems that are necessary to achieve organizational or regulatory goals.

Cardinality: 0..*

Constraints: cnl-0 | warning | Name should be usable as an identifier for the module by machine processing applications such as code generation | name.exists() implies name.matches('^A-Z{1,254}$'); req-1 | error | Actor Keys must be unique | Requirements.actor.key.isDistinct()

Mappings: w5=conformance.content; workflow=Definition

Requirements.url

Canonical identifier for this Requirements, represented as a URI (globally unique)

Definition: An absolute URI that is used to identify this Requirements 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 an authoritative instance of this Requirements is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the Requirements is stored on different servers.

Comments: Can be a urn:uuid: or a urn:oid: but real http: addresses are preferred. Multiple instances may share the same URL if they have a distinct version.

The determination of when to create a new version of a resource (same url, new version) vs. defining a new artifact is up to the author. Considerations for making this decision are found in Technical and Business Versions.

In some cases, the resource can no longer be found at the stated url, but the url itself cannot change. Implementations can use the meta.source element to indicate where the current master source of the resource can be found.

Requirements: Allows the Requirements to be referenced by a single globally unique identifier.

Cardinality: 0..1

Type: uri

Summary: true

Mappings: w5=FiveWs.identifier; workflow=Definition.url

Requirements.identifier

Additional identifier for the Requirements (business identifier)

Definition: A formal identifier that is used to identify this Requirements when it is represented in other formats, or referenced in a specification, model, design or an instance.

Requirements: Allows externally provided and/or usable business identifiers to be easily associated with the module.

Cardinality: 0..*

Type: Identifier

Summary: true

Mappings: w5=FiveWs.identifier; workflow=Definition.identifier

Requirements.version

Business version of the Requirements

Definition: The identifier that is used to identify this version of the Requirements when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the Requirements 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.

Comments: There may be different Requirements instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a reference to a particular business version of the Requirements with the format [url]|[version]. The version SHOULD NOT contain a '#' - see Business Version.

Cardinality: 0..1

Type: string

Summary: true

Mappings: w5=FiveWs.version; workflow=Definition.version

Requirements.versionAlgorithm[x]

How to compare versions

Definition: Indicates the mechanism used to compare versions to determine which is more current.

Comments: If set as a string, this is a FHIRPath expression that has two additional context variables passed in - %version1 and %version2 and will return a negative number if version1 is newer, a positive number if version2 and a 0 if the version ordering can't be successfully be determined.

Cardinality: 0..1

Type: string, Coding

Binding: extensible:version-algorithm

Summary: true

Mappings: workflow=Definition.versionAlgorithm

Requirements.name

Name for this Requirements (computer friendly)

Definition: A natural language name identifying the Requirements. This name should be usable as an identifier for the module by machine processing applications such as code generation.

Comments: The name is not expected to be globally unique. The name should be a simple alphanumeric type name to ensure that it is machine-processing friendly.

Requirements: Support human navigation and code generation.

Conditions: cnl-0

Cardinality: 0..1

Type: string

Summary: true

Mappings: workflow=Definition.name

Requirements.title

Name for this Requirements (human friendly)

Definition: A short, descriptive, user-friendly title for the Requirements.

Comments: This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.

Cardinality: 0..1

Type: string

Summary: true

Mappings: workflow=Definition.title

Requirements.status

draft | active | retired | unknown

Definition: The status of this Requirements. Enables tracking the life-cycle of the content.

Comments: Allows filtering of Requirements that are appropriate for use versus not.

See guidance around (not) making local changes to elements here.

Cardinality: 1..1

Type: code

Binding: required:publication-status

Summary: true

Is Modifier: true (Reason: This is labeled as "Is Modifier" because designs and applications should not use a retired Requirements without due consideration)

Mappings: w5=FiveWs.status; workflow=Definition.status

Requirements.experimental

For testing only - never for real usage

Definition: A Boolean value to indicate that this Requirements is authored for testing purposes (or education/evaluation/marketing) and no version of this resource will ever be intended for genuine usage.

Comments: Allows filtering of Requirements that are appropriate for use versus not.. Experimental resources might include example instances in implementation guides, instances created solely for testing purposes, etc

Requirements: Enables experimental content to be developed following the same lifecycle that would be used for a production-level Requirements.

Meaning if Missing: If absent, this resource is treated as though it is not experimental.

Cardinality: 0..1

Type: boolean

Summary: true

Mappings: workflow=Definition.experimental

Requirements.date

Date last changed

Definition: The date (and optionally time) when the Requirements was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the Requirements changes.

Comments: Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the Requirements. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.

See guidance around (not) making local changes to elements here.

Aliases: Revision Date

Cardinality: 0..1

Type: dateTime

Summary: true

Mappings: w5=FiveWs.recorded; workflow=Definition.date

Requirements.publisher

Name of the publisher/steward (organization or individual)

Definition: The name of the organization or individual responsible for the release and ongoing maintenance of the Requirements.

Comments: Usually an organization but may be an individual. The publisher (or steward) of the Requirements is the organization or individual primarily responsible for the maintenance and upkeep of the Requirements. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the Requirements. This item SHOULD be populated unless the information is available from context.

Requirements: Helps establish the "authority/credibility" of the Requirements. May also allow for contact.

Cardinality: 0..1

Type: string

Summary: true

Mappings: w5=FiveWs.witness; workflow=Definition.publisher

Requirements.contact

Contact details for the publisher

Definition: Contact details to assist a user in finding and communicating with the publisher.

Comments: May be a web site, an email address, a telephone number, etc.

See guidance around (not) making local changes to elements here.

Cardinality: 0..*

Type: ContactDetail

Summary: true

Mappings: workflow=Definition.contact

Requirements.description

Natural language description of the requirements

Definition: A free text natural language description of the requirements.

Comments: This description can be used for a general description of the requirements, and which covers why it was defined.

Aliases: Scope, Purpose

Cardinality: 0..1

Type: markdown

Mappings: workflow=Definition.description

Requirements.useContext

The context that the content is intended to support

Definition: 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 Requirements instances.

Comments: When multiple useContexts are specified, there is no expectation that all or any of the contexts apply.

Requirements: Assist in searching for appropriate content.

Cardinality: 0..*

Type: UsageContext

Summary: true

Mappings: workflow=Definition.useContext

Requirements.jurisdiction

Jurisdiction of the authority that maintains the Requirements (if applicable)

Definition: A legal or geographic region in which the authority that maintains the resource is operating. In general, the jurisdiction is also found in the useContext. The useContext may reference additional jurisdictions because the defining jurisdiction does not necessarily limit the jurisdictions of use.

Comments: It may be possible for the Requirements to be used in jurisdictions other than those for which it was originally designed or intended

DEPRECATION NOTE: For consistency, implementations are encouraged to migrate to using the new 'jurisdiction' code in the useContext element. (I.e. useContext.code indicating http://terminology.hl7.org/CodeSystem/usage-context-type#jurisdiction and useContext.valueCodeableConcept indicating the jurisdiction.).

Cardinality: 0..*

Type: CodeableConcept

Binding: extensible:jurisdiction

Summary: true

Mappings: workflow=Definition.jurisdiction

Requirements.purpose

Why this Requirements is defined

Definition: Explanation of why this Requirements is needed and why it has been designed as it has.

Comments: This element does not describe the usage of the Requirements. Instead, it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this Requirements.

Cardinality: 0..1

Type: markdown

Mappings: w5=FiveWs.why[x]; workflow=Definition.purpose

Requirements.copyright

Notice about intellectual property ownership, can include restrictions on use

Definition: A copyright statement relating to the Requirements and/or its contents. Copyright statements are notices of intellectual property ownership and can include restrictions on the use and publishing of the Requirements.

Comments: ...

Requirements: Consumers must be able to determine any legal restrictions on the use of the Requirements.

Aliases: License, Restrictions

Cardinality: 0..1

Type: markdown

Mappings: workflow=Definition.copyright

Requirements.copyrightLabel

Definition: A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are restricted. (e.g. 'All rights reserved', 'Some rights reserved').

Comments: The copyright symbol and the '(c)' textual representation SHOULD NOT be included in this string. It will be added by software when rendering the notation. Full details about licensing, restrictions, warrantees, etc. goes in the more general 'copyright' element.

Requirements: Defines the content expected to be rendered in all representations of the artifact.

Cardinality: 0..1

Type: string

Mappings: workflow=Definition.copyrightLabel

Requirements.derivedFrom

Other set of Requirements this builds on

Definition: Another set of Requirements that this set of Requirements builds on and updates.

Comments: Existing statements (by key) may be narrowed or clarified, and additional statements added.

Cardinality: 0..*

Type: canonical

Summary: true

Mappings: workflow=Definition.derivedFromCanonical

Requirements.imports

External requirements that apply here

Definition: Points to requirements defined elsewhere that have the same force as if they were defined in this instance.

Comments: A given requirement should either appear here OR be listed as a derivedFrom in a statement, but not both. I.e. you either include the referenced requirement unchanged or you include it in a qualified manner.

Cardinality: 0..*

Summary: true

Requirements.imports.reference

Source of imported statements

Definition: The canonical for the Requirements resource to import statements from.

Cardinality: 1..1

Type: canonical

Summary: true

Requirements.imports.key

Statement key

Definition: The key of a statement to treat as part of the set of requirements defined in this instance.

Comments: If no keys are specified, then the interpretation is that all statements in the referenced Requirements instance apply to this instance.

Cardinality: 0..*

Type: id

Requirements.reference

External artifact (rule/document etc. that) created this set of requirements

Definition: A reference to another artifact that created this set of requirements. This could be a profile, etc., or external regulation, or business requirements expressed elsewhere. This URI is intended to point to a specific web page for an artifact, not a canonical URL. If pointing to HL7 specifications, it is best to point to the version-specific URL.

Cardinality: 0..*

Type: url

Requirements.actor

Actor for these requirements

Definition: An actor these requirements are in regard to.

Comments: If more than one actor is specified, then it's up to the statements to explicitly identify the actors that are relevant if the statement doesn't apply to all actors.

Cardinality: 0..*

Mappings: w5=FiveWs.who

Requirements.actor.reference

Actor referenced

Definition: The canonical for an actor relevant to some of the requirements.

Cardinality: 1..1

Type: canonical

Summary: true

Requirements.actor.key

Unique label for actor (used in statements)

Definition: A unique string used to reference the actor from specific requirements.

Cardinality: 0..1

Type: id

Summary: true

Requirements.statement

Conformance requirement statement

Definition: The actual statement of conformance requirement.

Cardinality: 0..*

Type: BackboneElement

Requirements.statement.key

Key that identifies this statement

Definition: Key that identifies this statement (unique within this resource).

Comments: Refer directly to the statement by {url}#{key}

Cardinality: 1..1

Type: id

Summary: true

Requirements.statement.label

Short Human label for this statement

Definition: A short human usable label for this statement.

Comments: The key is intended for computers, while this is intended for humans. In its absence, the key should be convenient for a human to say (e.g. not a UUID)

Cardinality: 0..1

Type: string

Requirements.statement.conformance

SHALL | SHOULD | MAY | SHOULD-NOT | SHALL-NOT

Definition: A short human usable label for this statement.

Comments: The conformance code is extracted from the requirement to make indexing and display easier. The requirement needs to express the conformance verbs directly in the markdown content. It's not unusual to mix verbs in a single sentence (e.g. System SHALL do X and SHOULD do Y)

Requirements: This element is allowed to repeat because a single requirements statement might contain multiple conformance words and thus need to be indexed under multiple conformance categories.

Cardinality: 0..*

Type: code

Binding: required:conformance-expectation

Requirements.statement.conditionality

Set to true if requirements statement is conditional

Definition: This boolean flag is set to true of the text of the requirement is conditional on something e.g. it includes language like 'if x then y'. This conditionality flag is introduced for purposes of filtering and colour highlighting etc.

Comments: There is no intent that the conditional statement by evaluatable

Cardinality: 0..1

Type: boolean

Requirements.statement.requirement

The actual requirement

Definition: The actual requirement for human consumption.

Cardinality: 1..1

Type: markdown

Summary: true

Requirements.statement.category

High level categorization of a statement

Definition: Categorization might be done automatically (inferred by code) or manually by user assertion. The absence of a category may limit the ability to determine when the element should be handled, so strong consideration should be given to how systems will be able to determine category values for legacy data and how data that cannot be categorized will be handled. As well, some categories might not be mutually exclusive, so systems should prepare for multiple declared categories - even within a single category 'axis'.

Cardinality: 0..*

Type: Coding

Binding: example

Summary: true

Mappings: w5=FiveWs.class

Requirements.statement.derivedFrom

Another statement this is refining, tightening, or establishing more context for

Definition: Indicates that this statement is refining, tightening, or establishing more context for the referenced requirement/statement.

Comments: With derivedFrom, the scope of what is being accomplished is the same (as opposed to partOf, where the scope of what is being accomplished by the part is narrower). If only the key is populated, this means the statement derives from another sibling statement in the same Requirements resource. If both key and canonical are populated, this indicates the statement derives from an external Requirements resource. The canonical must point to one of the Requirements.derivedFrom values present in the current resource.

Cardinality: 0..1

Requirements.statement.derivedFrom.reference

Pointer to Requirements instance

Definition: The canonical of the Requirements instance this statement is derivedFrom.

Cardinality: 0..1

Type: canonical

Requirements.statement.derivedFrom.key

Key of referenced statement

Definition: The key, either within this resource or the specified Requirements resource this statement is derivedFrom.

Cardinality: 1..1

Type: id

Requirements.statement.partOf

Higher-level requirement or statement which this is a logical sub-requirement of

Definition: Identifies a higher-level requirement or statement which this referencing statement is a logical sub-requirement of. I.e. This statement is a necessary step to achieving the referenced requirement/statement.

Comments: If only the key is populated, this is partOf a statement within the same Requirements resource. If both key and canonical are populated, this is partOf a statement in an external Requirements resource.

Requirements: Allows requirements to be organized compositionally. E.g. Epic/Story/Task.

Cardinality: 0..1

Requirements.statement.partOf.reference

Pointer to Requirements instance

Definition: The canonical of the Requirements instance this statement is a part of.

Cardinality: 0..1

Type: canonical

Requirements.statement.partOf.key

Key of referenced statement

Definition: The key, either within this resource or the specified Requirements resource this statement is a part of.

Cardinality: 1..1

Type: id

Requirements.statement.satisfiedBy

Design artifact that satisfies this requirement

Definition: A reference to another artifact that satisfies this requirement. This could be a profile, extension, or an element in one of those, or a CapabilityStatement, OperationDefinition, SearchParameter, CodeSystem(/code), ValueSet, Library etc.

Comments: This is for use when the requirement is met be a pre-existing artifact e.g. a rule that's met by the base FHIR spec, or a national implementation guide. It is more typical to point from the FHIR artifact satisfying the requirement to the requirement (using the satisfies-requirement extension) to the Requirements resource. However, in some cases the author of the Requirements and satisfying resource(s) won't be coordinated in that manner and this element allows assertion of satisfaction without involvement from those managing the implementing artifacts.

Cardinality: 0..*

Type: url

Requirements.statement.reference

External artifact (rule/document etc. that) created this requirement

Definition: A reference to another artifact that created this requirement. This could be a profile, etc., or external regulation, or business requirements expressed elsewhere. This URI is intended to point to a specific web page for an artifact, not a canonical URL. If pointing to HL7 specifications, it is best to point to the version-specific URL.

Cardinality: 0..*

Type: url

Requirements.statement.source

Who asked for this statement

Definition: Who asked for this statement to be a requirement. By default, it's assumed that the publisher knows who it is if it matters.

Cardinality: 0..*

Type: Reference(CareTeam, Device, Group, HealthcareService, Organization, Patient, Practitioner, PractitionerRole, RelatedPerson)

Mappings: w5=FiveWs.source

Requirements.statement.actor

Key of relevant actor

Definition: A reference to the key of an actor listed in Requirements.actor that is relevant to this requirement statement.

Comments: If not specified, all actors listed on the Requirements is presumed to be relevant to the statement.

Cardinality: 0..*

Type: id

Constraints: req-2 | error | Statement Actors must match a defined actor | $this in %resource.actor.key