0
# Clinical Resources
1

2
Clinical data resources for comprehensive healthcare documentation including observations, conditions, procedures, medications, and diagnostic reports. These resources capture the clinical aspects of patient care and medical history.
3

4
## Capabilities
5

6
### Observations
7

8
Clinical observations, measurements, and assessments including vital signs, laboratory results, and clinical findings.
9

10
```python { .api }
11
class Observation(DomainResource):
12
    """Clinical observation, measurement, or assertion"""
13
    def __init__(
14
        self,
15
        # Core observation data
16
        identifier: Optional[List["Identifier"]] = None,
17
        status: str,  # registered | preliminary | final | amended | corrected | cancelled | entered-in-error | unknown
18
        category: Optional[List["CodeableConcept"]] = None,
19
        code: "CodeableConcept",
20
        subject: Optional["Reference"] = None,
21
        
22
        # Context and timing
23
        encounter: Optional["Reference"] = None,
24
        effectiveDateTime: Optional[str] = None,  # DateTime
25
        effectivePeriod: Optional["Period"] = None,
26
        effectiveTiming: Optional["Timing"] = None,
27
        effectiveInstant: Optional[str] = None,  # Instant
28
        issued: Optional[str] = None,  # Instant
29
        
30
        # Value and results
31
        valueQuantity: Optional["Quantity"] = None,
32
        valueCodeableConcept: Optional["CodeableConcept"] = None,
33
        valueString: Optional[str] = None,
34
        valueBoolean: Optional[bool] = None,
35
        valueInteger: Optional[int] = None,
36
        valueRange: Optional["Range"] = None,
37
        valueRatio: Optional["Ratio"] = None,
38
        valueSampledData: Optional["SampledData"] = None,
39
        valueTime: Optional[str] = None,  # Time
40
        valueDateTime: Optional[str] = None,  # DateTime
41
        valuePeriod: Optional["Period"] = None,
42
        valueAttachment: Optional["Attachment"] = None,
43
        
44
        # Interpretation and reference ranges
45
        dataAbsentReason: Optional["CodeableConcept"] = None,
46
        interpretation: Optional[List["CodeableConcept"]] = None,
47
        note: Optional[List["Annotation"]] = None,
48
        bodySite: Optional["CodeableConcept"] = None,
49
        method: Optional["CodeableConcept"] = None,
50
        specimen: Optional["Reference"] = None,
51
        device: Optional["Reference"] = None,
52
        referenceRange: Optional[List["ObservationReferenceRange"]] = None,
53
        
54
        # Related observations
55
        hasMember: Optional[List["Reference"]] = None,
56
        derivedFrom: Optional[List["Reference"]] = None,
57
        component: Optional[List["ObservationComponent"]] = None,
58
        
59
        # Performers
60
        performer: Optional[List["Reference"]] = None,
61
        
62
        **kwargs
63
    ): ...
64
```
65

66
**Usage Example:**
67

68
```python
69
from fhir.resources.observation import Observation
70
from fhir.resources.codeableconcept import CodeableConcept
71
from fhir.resources.coding import Coding
72
from fhir.resources.quantity import Quantity
73
from fhir.resources.reference import Reference
74

75
# Blood pressure observation
76
bp_observation = Observation(
77
    status="final",
78
    category=[
79
        CodeableConcept(
80
            coding=[Coding(
81
                system="http://terminology.hl7.org/CodeSystem/observation-category",
82
                code="vital-signs",
83
                display="Vital Signs"
84
            )]
85
        )
86
    ],
87
    code=CodeableConcept(
88
        coding=[Coding(
89
            system="http://loinc.org",
90
            code="85354-9",
91
            display="Blood pressure panel with all children optional"
92
        )]
93
    ),
94
    subject=Reference(
95
        reference="Patient/patient-001"
96
    ),
97
    effectiveDateTime="2024-01-15T10:30:00Z",
98
    component=[
99
        ObservationComponent(
100
            code=CodeableConcept(
101
                coding=[Coding(
102
                    system="http://loinc.org",
103
                    code="8480-6",
104
                    display="Systolic blood pressure"
105
                )]
106
            ),
107
            valueQuantity=Quantity(
108
                value=120,
109
                unit="mmHg",
110
                system="http://unitsofmeasure.org",
111
                code="mm[Hg]"
112
            )
113
        ),
114
        ObservationComponent(
115
            code=CodeableConcept(
116
                coding=[Coding(
117
                    system="http://loinc.org", 
118
                    code="8462-4",
119
                    display="Diastolic blood pressure"
120
                )]
121
            ),
122
            valueQuantity=Quantity(
123
                value=80,
124
                unit="mmHg",
125
                system="http://unitsofmeasure.org",
126
                code="mm[Hg]"
127
            )
128
        )
129
    ]
130
)
131
```
132

133
### Conditions
134

135
Medical conditions, diagnoses, and health problems affecting the patient.
136

137
```python { .api }
138
class Condition(DomainResource):
139
    """Medical condition, diagnosis, or health problem"""
140
    def __init__(
141
        self,
142
        # Core condition data
143
        identifier: Optional[List["Identifier"]] = None,
144
        clinicalStatus: Optional["CodeableConcept"] = None,
145
        verificationStatus: Optional["CodeableConcept"] = None,
146
        category: Optional[List["CodeableConcept"]] = None,
147
        severity: Optional["CodeableConcept"] = None,
148
        code: Optional["CodeableConcept"] = None,
149
        bodySite: Optional[List["CodeableConcept"]] = None,
150
        subject: "Reference",
151
        
152
        # Context and timing
153
        encounter: Optional["Reference"] = None,
154
        onsetDateTime: Optional[str] = None,  # DateTime
155
        onsetAge: Optional["Age"] = None,
156
        onsetPeriod: Optional["Period"] = None,
157
        onsetRange: Optional["Range"] = None,
158
        onsetString: Optional[str] = None,
159
        abatementDateTime: Optional[str] = None,  # DateTime
160
        abatementAge: Optional["Age"] = None,
161
        abatementPeriod: Optional["Period"] = None,
162
        abatementRange: Optional["Range"] = None,
163
        abatementString: Optional[str] = None,
164
        recordedDate: Optional[str] = None,  # DateTime
165
        
166
        # Clinical details
167
        stage: Optional[List["ConditionStage"]] = None,
168
        evidence: Optional[List["ConditionEvidence"]] = None,
169
        note: Optional[List["Annotation"]] = None,
170
        
171
        # Recorder and asserter
172
        recorder: Optional["Reference"] = None,
173
        asserter: Optional["Reference"] = None,
174
        
175
        **kwargs
176
    ): ...
177
```
178

179
**Usage Example:**
180

181
```python
182
from fhir.resources.condition import Condition
183

184
# Diabetes diagnosis
185
diabetes_condition = Condition(
186
    clinicalStatus=CodeableConcept(
187
        coding=[Coding(
188
            system="http://terminology.hl7.org/CodeSystem/condition-clinical",
189
            code="active",
190
            display="Active"
191
        )]
192
    ),
193
    verificationStatus=CodeableConcept(
194
        coding=[Coding(
195
            system="http://terminology.hl7.org/CodeSystem/condition-ver-status",
196
            code="confirmed",
197
            display="Confirmed"
198
        )]
199
    ),
200
    category=[
201
        CodeableConcept(
202
            coding=[Coding(
203
                system="http://terminology.hl7.org/CodeSystem/condition-category",
204
                code="encounter-diagnosis",
205
                display="Encounter Diagnosis"
206
            )]
207
        )
208
    ],
209
    code=CodeableConcept(
210
        coding=[Coding(
211
            system="http://snomed.info/sct",
212
            code="44054006",
213
            display="Diabetes mellitus type 2"
214
        )]
215
    ),
216
    subject=Reference(
217
        reference="Patient/patient-001"
218
    ),
219
    onsetDateTime="2020-06-15",
220
    recordedDate="2020-06-15T14:30:00Z"
221
)
222
```
223

224
### Procedures
225

226
Medical procedures, surgeries, and therapeutic interventions performed on patients.
227

228
```python { .api }
229
class Procedure(DomainResource):
230
    """Medical procedure performed on patient"""
231
    def __init__(
232
        self,
233
        # Core procedure data
234
        identifier: Optional[List["Identifier"]] = None,
235
        instantiatesCanonical: Optional[List[str]] = None,
236
        instantiatesUri: Optional[List[str]] = None,
237
        basedOn: Optional[List["Reference"]] = None,
238
        partOf: Optional[List["Reference"]] = None,
239
        status: str,  # preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown
240
        statusReason: Optional["CodeableConcept"] = None,
241
        category: Optional[List["CodeableConcept"]] = None,
242
        code: Optional["CodeableConcept"] = None,
243
        subject: "Reference",
244
        
245
        # Context and timing
246
        encounter: Optional["Reference"] = None,
247
        occurrenceDateTime: Optional[str] = None,  # DateTime
248
        occurrencePeriod: Optional["Period"] = None,
249
        occurrenceString: Optional[str] = None,
250
        occurrenceAge: Optional["Age"] = None,
251
        occurrenceRange: Optional["Range"] = None,
252
        occurrenceTiming: Optional["Timing"] = None,
253
        recorded: Optional[str] = None,  # DateTime
254
        
255
        # Clinical details
256
        recorder: Optional["Reference"] = None,
257
        reportedBoolean: Optional[bool] = None,
258
        reportedReference: Optional["Reference"] = None,
259
        performer: Optional[List["ProcedurePerformer"]] = None,
260
        location: Optional["Reference"] = None,
261
        reason: Optional[List["CodeableReference"]] = None,
262
        bodySite: Optional[List["CodeableConcept"]] = None,
263
        outcome: Optional["CodeableConcept"] = None,
264
        report: Optional[List["Reference"]] = None,
265
        complication: Optional[List["CodeableReference"]] = None,
266
        followUp: Optional[List["CodeableConcept"]] = None,
267
        note: Optional[List["Annotation"]] = None,
268
        
269
        # Devices and supplies
270
        focalDevice: Optional[List["ProcedureFocalDevice"]] = None,
271
        used: Optional[List["CodeableReference"]] = None,
272
        supportingInfo: Optional[List["Reference"]] = None,
273
        
274
        **kwargs
275
    ): ...
276
```
277

278
### Medication Resources
279

280
Medication administration, dispensing, requests, and statements for comprehensive medication management.
281

282
```python { .api }
283
class MedicationRequest(DomainResource):
284
    """Prescription or medication order"""
285
    def __init__(
286
        self,
287
        # Core request data
288
        identifier: Optional[List["Identifier"]] = None,
289
        status: str,  # active | on-hold | cancelled | completed | entered-in-error | stopped | draft | unknown
290
        statusReason: Optional["CodeableConcept"] = None,
291
        intent: str,  # proposal | plan | order | original-order | reflex-order | filler-order | instance-order | option
292
        category: Optional[List["CodeableConcept"]] = None,
293
        priority: Optional[str] = None,  # routine | urgent | asap | stat
294
        doNotPerform: Optional[bool] = None,
295
        medication: "CodeableReference",
296
        subject: "Reference",
297
        
298
        # Context and timing
299
        informationSource: Optional[List["Reference"]] = None,
300
        encounter: Optional["Reference"] = None,
301
        supportingInformation: Optional[List["Reference"]] = None,
302
        authoredOn: Optional[str] = None,  # DateTime
303
        requester: Optional["Reference"] = None,
304
        reported: Optional[bool] = None,
305
        performer: Optional[List["Reference"]] = None,
306
        device: Optional[List["Reference"]] = None,
307
        recorder: Optional["Reference"] = None,
308
        
309
        # Dosage and administration
310
        reason: Optional[List["CodeableReference"]] = None,
311
        courseOfTherapyType: Optional["CodeableConcept"] = None,
312
        insurance: Optional[List["Reference"]] = None,
313
        note: Optional[List["Annotation"]] = None,
314
        renderedDosageInstruction: Optional[str] = None,
315
        effectiveDosePeriod: Optional["Period"] = None,
316
        dosageInstruction: Optional[List["Dosage"]] = None,
317
        
318
        # Dispensing details
319
        dispenseRequest: Optional["MedicationRequestDispenseRequest"] = None,
320
        substitution: Optional["MedicationRequestSubstitution"] = None,
321
        eventHistory: Optional[List["Reference"]] = None,
322
        
323
        **kwargs
324
    ): ...
325

326
class MedicationAdministration(DomainResource):
327
    """Record of medication given to patient"""
328
    def __init__(
329
        self,
330
        # Core administration data
331
        identifier: Optional[List["Identifier"]] = None,
332
        basedOn: Optional[List["Reference"]] = None,
333
        partOf: Optional[List["Reference"]] = None,
334
        status: str,  # in-progress | not-done | on-hold | completed | entered-in-error | stopped | unknown
335
        statusReason: Optional[List["CodeableConcept"]] = None,
336
        category: Optional[List["CodeableConcept"]] = None,
337
        medication: "CodeableReference",
338
        subject: "Reference",
339
        
340
        # Context and timing
341
        encounter: Optional["Reference"] = None,
342
        supportingInformation: Optional[List["Reference"]] = None,
343
        occurenceDateTime: Optional[str] = None,  # DateTime
344
        occurencePeriod: Optional["Period"] = None,
345
        recorded: Optional[str] = None,  # DateTime
346
        isSubPotent: Optional[bool] = None,
347
        subPotentReason: Optional[List["CodeableConcept"]] = None,
348
        performer: Optional[List["MedicationAdministrationPerformer"]] = None,
349
        reason: Optional[List["CodeableReference"]] = None,
350
        request: Optional["Reference"] = None,
351
        device: Optional[List["Reference"]] = None,
352
        note: Optional[List["Annotation"]] = None,
353
        
354
        # Dosage details
355
        dosage: Optional["MedicationAdministrationDosage"] = None,
356
        eventHistory: Optional[List["Reference"]] = None,
357
        
358
        **kwargs
359
    ): ...
360
```
361

362
### Diagnostic Reports
363

364
Results of diagnostic procedures including laboratory tests, imaging studies, and pathology reports.
365

366
```python { .api }
367
class DiagnosticReport(DomainResource):
368
    """Report of diagnostic procedure results"""
369
    def __init__(
370
        self,
371
        # Core report data
372
        identifier: Optional[List["Identifier"]] = None,
373
        basedOn: Optional[List["Reference"]] = None,
374
        status: str,  # registered | partial | preliminary | modified | final | amended | corrected | appended | cancelled | entered-in-error | unknown
375
        category: Optional[List["CodeableConcept"]] = None,
376
        code: "CodeableConcept",
377
        subject: Optional["Reference"] = None,
378
        encounter: Optional["Reference"] = None,
379
        
380
        # Timing and context
381
        effectiveDateTime: Optional[str] = None,  # DateTime
382
        effectivePeriod: Optional["Period"] = None,
383
        issued: Optional[str] = None,  # Instant
384
        performer: Optional[List["Reference"]] = None,
385
        resultsInterpreter: Optional[List["Reference"]] = None,
386
        specimen: Optional[List["Reference"]] = None,
387
        
388
        # Results and findings
389
        result: Optional[List["Reference"]] = None,
390
        note: Optional[List["Annotation"]] = None,
391
        study: Optional[List["Reference"]] = None,
392
        supportingInfo: Optional[List["DiagnosticReportSupportingInfo"]] = None,
393
        
394
        # Media and presentation
395
        media: Optional[List["DiagnosticReportMedia"]] = None,
396
        composition: Optional["Reference"] = None,
397
        conclusion: Optional[str] = None,
398
        conclusionCode: Optional[List["CodeableConcept"]] = None,
399
        presentedForm: Optional[List["Attachment"]] = None,
400
        
401
        **kwargs
402
    ): ...
403
```
404

405
## Types
406

407
```python { .api }
408
from typing import Optional, List
409
from fhir.resources.domainresource import DomainResource
410

411
# Clinical resource backbone elements
412
class ObservationComponent: ...
413
class ObservationReferenceRange: ...
414
class ConditionStage: ...
415
class ConditionEvidence: ...
416
class ProcedurePerformer: ...
417
class ProcedureFocalDevice: ...
418
class MedicationRequestDispenseRequest: ...
419
class MedicationRequestSubstitution: ...
420
class MedicationAdministrationPerformer: ...
421
class MedicationAdministrationDosage: ...
422
class DiagnosticReportSupportingInfo: ...
423
class DiagnosticReportMedia: ...
424

425
# Complex data types used in clinical resources
426
class Age: ...
427
class CodeableReference: ...
428
class SampledData: ...
429
class Timing: ...
430
class Dosage: ...
431
```