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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
//! ChargeItem
//!
//! URL: http://hl7.org/fhir/StructureDefinition/ChargeItem
//!
//! Version: 5.0.0
//!
//! ChargeItem Resource: The provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons.
//!
//! FHIR: <https://build.fhir.org/>
//!
//! UML: <https://build.fhir.org/uml.html>
// Allow unused crate::r5::types as types;
#![allow(unused_imports)]
use crate::r5::types;
use ::serde::{Deserialize, Serialize};
use fhir_derive_macros::Validate;
/// The resource ChargeItem describes the provision of healthcare provider
/// products for a certain patient, therefore referring not only to the product,
/// but containing in addition details of the provision, like date, time,
/// amounts and participating organizations and persons. The main usage of the
/// ChargeItem is to enable the billing process and internal cost allocation.
///
/// A ChargeItem is typically generated automatically or semi-automatically
/// whenever a billable event occurs during patient care, such as the
/// performance of a procedure, the dispensing of a medication, or the use of
/// a device or facility resource. It captures who or what performed the
/// service, when it occurred, the quantity and pricing information, and the
/// organizations that requested and performed the service, as well as any
/// override reasons applied to standard pricing rules. Downstream systems
/// aggregate ChargeItem instances, typically via an Invoice or similar
/// billing resource, to produce claims or patient statements.
///
/// # Related resources
///
/// - The `subject` of a ChargeItem is usually a
/// [`Patient`](crate::r5::resources::patient::Patient), and the `encounter`
/// field commonly references an `Encounter` during which the service was
/// rendered.
/// - Pricing and reason fields such as `code`, `bodysite`, `reason`, and
/// `override_reason` are represented using
/// [`CodeableConcept`](crate::r5::types::CodeableConcept).
/// - The `performer`, `enterer`, `cost_center`, `requesting_organization`,
/// and `performing_organization` fields link to actors via
/// [`Reference`](crate::r5::types::Reference).
///
/// # Examples
///
/// ```
/// use fhir::r5::resources::charge_item::ChargeItem;
///
/// let value = ChargeItem::default();
/// let json = ::serde_json::to_value(&value).unwrap();
/// let back: ChargeItem = ::serde_json::from_value(json).unwrap();
/// assert_eq!(value, back);
/// ```
#[serde_with::skip_serializing_none]
#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq, Validate)]
#[serde(rename_all = "camelCase")]
pub struct ChargeItem {
/// Logical id of this artifact
pub id: Option<types::String>,
/// Metadata about the resource
pub meta: Option<types::Meta>,
/// A set of rules under which this content was created
pub implicit_rules: Option<types::Uri>,
/// Language of the resource content
pub language: Option<types::Code>,
/// Text summary of the resource, for human interpretation
pub text: Option<types::Narrative>,
/// Contained, inline Resources
pub contained: Option<Vec<::serde_json::Value>>,
/// Additional content defined by implementations
pub extension: Option<Vec<types::Extension>>,
/// Extensions that cannot be ignored
pub modifier_extension: Option<Vec<types::Extension>>,
/// Business Identifier for item
pub identifier: Option<Vec<types::Identifier>>,
/// Defining information about the code of this charge item
pub definition_uri: Option<Vec<types::Uri>>,
/// Resource defining the code of this ChargeItem
pub definition_canonical: Option<Vec<types::Canonical>>,
/// The current lifecycle status of the charge: planned | billable | not-billable | aborted | billed | entered-in-error | unknown.
pub status: types::Code,
/// Part of referenced ChargeItem
pub part_of: Option<Vec<types::Reference>>,
/// A code that identifies the charge, like a billing code
pub code: types::CodeableConcept,
/// The individual, typically a `Patient`, for whom the charged service was performed
pub subject: types::Reference,
/// Encounter associated with this ChargeItem
pub encounter: Option<types::Reference>,
/// When the charged service was applied
pub occurrence_date_time: Option<types::DateTime>,
/// When the charged service was applied
pub occurrence_period: Option<types::Period>,
/// When the charged service was applied
pub occurrence_timing: Option<types::Timing>,
/// Who performed charged service
pub performer: Option<Vec<ChargeItemPerformer>>,
/// Organization providing the charged service
pub performing_organization: Option<types::Reference>,
/// Organization requesting the charged service
pub requesting_organization: Option<types::Reference>,
/// Organization that has ownership of the (potential, future) revenue
pub cost_center: Option<types::Reference>,
/// Quantity of the item or service being charged, e.g. the number of units administered
pub quantity: Option<types::Quantity>,
/// Anatomical location, if relevant
pub bodysite: Option<Vec<types::CodeableConcept>>,
/// Unit price overriding the associated rules
pub unit_price_component: Option<types::MonetaryComponent>,
/// Total price overriding the associated rules
pub total_price_component: Option<types::MonetaryComponent>,
/// Reason for overriding the list price/factor
pub override_reason: Option<types::CodeableConcept>,
/// Individual who was entering
pub enterer: Option<types::Reference>,
/// Date the charge item was entered
pub entered_date: Option<types::DateTime>,
/// Why was the charged service rendered?
pub reason: Option<Vec<types::CodeableConcept>>,
/// Which rendered service is being charged?
pub service: Option<Vec<types::CodeableReference>>,
/// Product charged
pub product: Option<Vec<types::CodeableReference>>,
/// Account to place this charge
pub account: Option<Vec<types::Reference>>,
/// Comments made about the ChargeItem
pub note: Option<Vec<types::Annotation>>,
/// Further information supporting this charge
pub supporting_information: Option<Vec<types::Reference>>,
}
/// Who performed charged service.
///
/// Indicates who or what performed or participated in the charged service.
#[serde_with::skip_serializing_none]
#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq, Validate)]
#[serde(rename_all = "camelCase")]
pub struct ChargeItemPerformer {
/// Unique id for inter-element referencing
pub id: Option<types::String>,
/// Additional content defined by implementations
pub extension: Option<Vec<types::Extension>>,
/// Extensions that cannot be ignored even if unrecognized
pub modifier_extension: Option<Vec<types::Extension>>,
/// What type of performance was done
pub function: Option<types::CodeableConcept>,
/// Individual who was performing
pub actor: types::Reference,
}
#[cfg(test)]
mod tests {
use super::*;
type T = ChargeItem;
#[test]
fn test_default() {
let _ = T::default();
}
#[test]
fn test_serde_round_trip() {
let value = T::default();
let json = ::serde_json::to_value(&value).expect("to_value");
let back: T = ::serde_json::from_value(json).expect("from_value");
assert_eq!(value, back);
}
}