fhir 1.2.0

Fast Healthcare Interoperability Resources (FHIR) data model for Rust: the complete FHIR R5, R4, and R3 resources, datatypes, and code systems as serde-serializable types, plus a spec-driven code generator.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Parse the FHIR R5 `all.json` specification bundle.
//!
//! This module reads the official FHIR R5 definitions file `all.json`, located
//! under the crate's `doc/fhir-specifications/r5/fhir-definitions-json`
//! directory and referenced here via `DEFINITIONS_FILE`. That bundle aggregates
//! the shared structural building blocks used throughout the specification, such
//! as codings, codeable concepts, identifiers, periods, quantities, ranges,
//! extensions, and related metadata. For each of these building blocks this
//! module exposes a corresponding Rust type, defined in a dedicated submodule
//! and re-exported here for convenient access, for example `Coding`,
//! `CodeableConcept`, `Identifier`, `Period`, and `Quantity`. Each submodule
//! deserializes its slice of the `all.json` bundle into an intermediate Rust
//! struct and then renders that struct as formatted Rust source code, which the
//! generator writes out under the crate's tracked `tmp/out` directory for later
//! use, or hand-adaptation, as part of the `src/r5/types` datatype layer. Within
//! the wider generation pipeline this module is one of several parsers under
//! `crate::r5::parse`, alongside the parsers for concept maps, data elements,
//! profiles, search parameters, and value sets, that together turn the raw FHIR
//! JSON specifications into strongly typed Rust source code.

// Namespace conveniences

pub static DIR: std::sync::LazyLock<std::path::PathBuf> =
    std::sync::LazyLock::new(|| crate::r5::parse::DIR.join("all"));

pub static DEFINITIONS_FILE: std::sync::LazyLock<std::path::PathBuf> =
    std::sync::LazyLock::new(|| crate::DEFINITIONS_DIR.join("all.json"));

// Submodules

pub mod additional {
    pub mod additional;
}
pub use additional::additional::Additional;

pub mod additional_attribute {
    pub mod additional_attribute;
}
pub use additional_attribute::additional_attribute::AdditionalAttribute;

pub mod binding {
    pub mod binding;
}
pub use binding::binding::Binding;

pub mod codeable_concept {
    pub mod codeable_concept;
}
pub use codeable_concept::codeable_concept::CodeableConcept;

pub mod coding {
    pub mod coding;
}
pub use coding::coding::Coding;

pub mod constraint {
    pub mod constraint;
}
pub use constraint::constraint::Constraint;

pub mod contact {
    pub mod contact;
}
pub use contact::contact::Contact;

pub mod depends_on {
    pub mod depends_on;
}
pub use depends_on::depends_on::DependsOn;

pub mod example {
    pub mod example;
}
pub use example::example::Example;

pub mod extension {
    pub mod extension;
}
pub use extension::extension::Extension;

pub mod element_type {
    pub mod element_type;
}
pub use element_type::element_type::ElementType;

pub mod identifier {
    pub mod identifier;
}
pub use identifier::identifier::Identifier;

pub mod jurisdiction {
    pub mod jurisdiction;
}
pub use jurisdiction::jurisdiction::Jurisdiction;

pub mod meta {
    pub mod meta;
}
pub use meta::meta::Meta;

pub mod period {
    pub mod period;
}
pub use period::period::Period;

pub mod property {
    pub mod property;
}
pub use property::property::Property;

pub mod quantity {
    pub mod quantity;
}
pub use quantity::quantity::Quantity;

pub mod range {
    pub mod range;
}
pub use range::range::Range;

pub mod related_artifact {
    pub mod related_artifact;
}
pub use related_artifact::related_artifact::RelatedArtifact;

pub mod target {
    pub mod target;
}
pub use target::target::Target;

pub mod topic {
    pub mod topic;
}
pub use topic::topic::Topic;

pub mod r#type {
    pub mod r#type;
}
pub use r#type::r#type::r#Type;

pub mod underscore_code {
    pub mod underscore_code;
}
pub use underscore_code::underscore_code::UnderscoreCode;