0
# Administrative Resources
1

2
Healthcare administration resources for operational management including appointments, encounters, organizations, practitioners, and schedules. These resources support the business and administrative aspects of healthcare delivery.
3

4
## Capabilities
5

6
### Appointments and Scheduling
7

8
Appointment booking, scheduling, and availability management for healthcare services.
9

10
```python { .api }
11
class Appointment(DomainResource):
12
    """Booking for healthcare service between patient(s) and practitioner(s)"""
13
    def __init__(
14
        self,
15
        # Core appointment data
16
        identifier: Optional[List["Identifier"]] = None,
17
        status: str,  # proposed | pending | booked | arrived | fulfilled | cancelled | noshow | entered-in-error | checked-in | waitlist
18
        cancellationReason: Optional["CodeableConcept"] = None,
19
        class_: Optional[List["CodeableConcept"]] = None,
20
        serviceCategory: Optional[List["CodeableConcept"]] = None,
21
        serviceType: Optional[List["CodeableReference"]] = None,
22
        specialty: Optional[List["CodeableConcept"]] = None,
23
        appointmentType: Optional["CodeableConcept"] = None,
24
        reason: Optional[List["CodeableReference"]] = None,
25
        
26
        # Priority and urgency
27
        priority: Optional["CodeableConcept"] = None,
28
        description: Optional[str] = None,
29
        replaces: Optional[List["Reference"]] = None,
30
        
31
        # Timing and duration
32
        start: Optional[str] = None,  # Instant
33
        end: Optional[str] = None,  # Instant
34
        minutesDuration: Optional[int] = None,
35
        requestedPeriod: Optional[List["Period"]] = None,
36
        
37
        # Participants and locations
38
        slot: Optional[List["Reference"]] = None,
39
        account: Optional[List["Reference"]] = None,
40
        created: Optional[str] = None,  # DateTime
41
        cancellationDate: Optional[str] = None,  # DateTime
42
        note: Optional[List["Annotation"]] = None,
43
        patientInstruction: Optional[List["CodeableReference"]] = None,
44
        basedOn: Optional[List["Reference"]] = None,
45
        subject: Optional["Reference"] = None,
46
        participant: List["AppointmentParticipant"],
47
        
48
        # Recurrence
49
        recurrenceId: Optional[int] = None,
50
        occurrenceChanged: Optional[bool] = None,
51
        recurrenceTemplate: Optional[List["AppointmentRecurrenceTemplate"]] = None,
52
        
53
        **kwargs
54
    ): ...
55

56
class Schedule(DomainResource):
57
    """Container for time slots for booking appointments"""
58
    def __init__(
59
        self,
60
        # Core schedule data
61
        identifier: Optional[List["Identifier"]] = None,
62
        active: Optional[bool] = None,
63
        serviceCategory: Optional[List["CodeableConcept"]] = None,
64
        serviceType: Optional[List["CodeableReference"]] = None,
65
        specialty: Optional[List["CodeableConcept"]] = None,
66
        name: Optional[str] = None,
67
        
68
        # Participants and actors
69
        actor: List["Reference"],
70
        
71
        # Timing and availability
72
        planningHorizon: Optional["Period"] = None,
73
        comment: Optional[str] = None,
74
        
75
        **kwargs
76
    ): ...
77

78
class Slot(DomainResource):
79
    """Time slot for appointment booking"""
80
    def __init__(
81
        self,
82
        # Core slot data
83
        identifier: Optional[List["Identifier"]] = None,
84
        serviceCategory: Optional[List["CodeableConcept"]] = None,
85
        serviceType: Optional[List["CodeableReference"]] = None,
86
        specialty: Optional[List["CodeableConcept"]] = None,
87
        appointmentType: Optional[List["CodeableConcept"]] = None,
88
        schedule: "Reference",
89
        
90
        # Availability and timing
91
        status: str,  # busy | free | busy-unavailable | busy-tentative | entered-in-error
92
        start: str,  # Instant
93
        end: str,  # Instant
94
        overbooked: Optional[bool] = None,
95
        comment: Optional[str] = None,
96
        
97
        **kwargs
98
    ): ...
99
```
100

101
**Usage Example:**
102

103
```python
104
from fhir.resources.appointment import Appointment
105
from fhir.resources.appointmentparticipant import AppointmentParticipant
106
from fhir.resources.reference import Reference
107
from fhir.resources.codeableconcept import CodeableConcept
108

109
# Create appointment for patient visit
110
appointment = Appointment(
111
    status="booked",
112
    serviceCategory=[
113
        CodeableConcept(
114
            coding=[Coding(
115
                system="http://terminology.hl7.org/CodeSystem/service-category",
116
                code="17",
117
                display="General Practice"
118
            )]
119
        )
120
    ],
121
    appointmentType=CodeableConcept(
122
        coding=[Coding(
123
            system="http://terminology.hl7.org/CodeSystem/v2-0276",
124
            code="ROUTINE",
125
            display="Routine appointment"
126
        )]
127
    ),
128
    description="Annual physical examination",
129
    start="2024-03-15T09:00:00Z",
130
    end="2024-03-15T09:30:00Z",
131
    minutesDuration=30,
132
    participant=[
133
        AppointmentParticipant(
134
            actor=Reference(
135
                reference="Patient/patient-001",
136
                display="Jane Smith"
137
            ),
138
            required=True,
139
            status="accepted"
140
        ),
141
        AppointmentParticipant(
142
            actor=Reference(
143
                reference="Practitioner/dr-jones",
144
                display="Dr. Sarah Jones"
145
            ),
146
            required=True,
147
            status="accepted"
148
        )
149
    ]
150
)
151
```
152

153
### Encounters
154

155
Healthcare encounters representing interactions between patients and healthcare providers.
156

157
```python { .api }
158
class Encounter(DomainResource):
159
    """Interaction between patient and healthcare provider"""
160
    def __init__(
161
        self,
162
        # Core encounter data
163
        identifier: Optional[List["Identifier"]] = None,
164
        status: str,  # planned | in-progress | on-hold | discharged | completed | cancelled | discontinued | entered-in-error | unknown
165
        class_: List["CodeableConcept"],
166
        priority: Optional["CodeableConcept"] = None,
167
        type: Optional[List["CodeableConcept"]] = None,
168
        serviceType: Optional[List["CodeableReference"]] = None,
169
        subject: Optional["Reference"] = None,
170
        subjectStatus: Optional["CodeableConcept"] = None,
171
        episodeOfCare: Optional[List["Reference"]] = None,
172
        
173
        # Participants
174
        basedOn: Optional[List["Reference"]] = None,
175
        careTeam: Optional[List["Reference"]] = None,
176
        partOf: Optional["Reference"] = None,
177
        serviceProvider: Optional["Reference"] = None,
178
        participant: Optional[List["EncounterParticipant"]] = None,
179
        
180
        # Timing and location
181
        appointment: Optional[List["Reference"]] = None,
182
        virtualService: Optional[List["VirtualServiceDetail"]] = None,
183
        actualPeriod: Optional["Period"] = None,
184
        plannedStartDate: Optional[str] = None,  # DateTime
185
        plannedEndDate: Optional[str] = None,  # DateTime
186
        length: Optional["Duration"] = None,
187
        reason: Optional[List["EncounterReason"]] = None,
188
        diagnosis: Optional[List["EncounterDiagnosis"]] = None,
189
        account: Optional[List["Reference"]] = None,
190
        dietPreference: Optional[List["CodeableConcept"]] = None,
191
        specialArrangement: Optional[List["CodeableConcept"]] = None,
192
        specialCourtesy: Optional[List["CodeableConcept"]] = None,
193
        
194
        # Admission and discharge
195
        admission: Optional["EncounterAdmission"] = None,
196
        location: Optional[List["EncounterLocation"]] = None,
197
        
198
        **kwargs
199
    ): ...
200
```
201

202
### Organizations and Practitioners
203

204
Healthcare organizations, practitioners, and their roles within the healthcare system.
205

206
```python { .api }
207
class Organization(DomainResource):
208
    """Healthcare organization"""
209
    def __init__(
210
        self,
211
        # Core organization data
212
        identifier: Optional[List["Identifier"]] = None,
213
        active: Optional[bool] = None,
214
        type: Optional[List["CodeableConcept"]] = None,
215
        name: Optional[str] = None,
216
        alias: Optional[List[str]] = None,
217
        description: Optional[str] = None,
218
        
219
        # Contact information
220
        contact: Optional[List["ExtendedContactDetail"]] = None,
221
        
222
        # Relationships
223
        partOf: Optional["Reference"] = None,
224
        endpoint: Optional[List["Reference"]] = None,
225
        
226
        # Qualifications
227
        qualification: Optional[List["OrganizationQualification"]] = None,
228
        
229
        **kwargs
230
    ): ...
231

232
class Practitioner(DomainResource):
233
    """Healthcare practitioner"""
234
    def __init__(
235
        self,
236
        # Core practitioner data
237
        identifier: Optional[List["Identifier"]] = None,
238
        active: Optional[bool] = None,
239
        name: Optional[List["HumanName"]] = None,
240
        telecom: Optional[List["ContactPoint"]] = None,
241
        address: Optional[List["Address"]] = None,
242
        gender: Optional[str] = None,  # male | female | other | unknown
243
        birthDate: Optional[str] = None,  # Date
244
        
245
        # Professional details
246
        photo: Optional[List["Attachment"]] = None,
247
        qualification: Optional[List["PractitionerQualification"]] = None,
248
        communication: Optional[List["PractitionerCommunication"]] = None,
249
        
250
        **kwargs
251
    ): ...
252

253
class PractitionerRole(DomainResource):
254
    """Roles/organizations that the practitioner is associated with"""
255
    def __init__(
256
        self,
257
        # Core role data
258
        identifier: Optional[List["Identifier"]] = None,
259
        active: Optional[bool] = None,
260
        period: Optional["Period"] = None,
261
        practitioner: Optional["Reference"] = None,
262
        organization: Optional["Reference"] = None,
263
        code: Optional[List["CodeableConcept"]] = None,
264
        specialty: Optional[List["CodeableConcept"]] = None,
265
        
266
        # Contact and location
267
        location: Optional[List["Reference"]] = None,
268
        healthcareService: Optional[List["Reference"]] = None,
269
        contact: Optional[List["ExtendedContactDetail"]] = None,
270
        
271
        # Availability
272
        characteristic: Optional[List["CodeableConcept"]] = None,
273
        communication: Optional[List["CodeableConcept"]] = None,
274
        availability: Optional[List["Availability"]] = None,
275
        endpoint: Optional[List["Reference"]] = None,
276
        
277
        **kwargs
278
    ): ...
279
```
280

281
**Usage Example:**
282

283
```python
284
from fhir.resources.organization import Organization
285
from fhir.resources.practitioner import Practitioner
286
from fhir.resources.practitionerrole import PractitionerRole
287

288
# Healthcare organization
289
hospital = Organization(
290
    active=True,
291
    type=[
292
        CodeableConcept(
293
            coding=[Coding(
294
                system="http://terminology.hl7.org/CodeSystem/organization-type",
295
                code="prov",
296
                display="Healthcare Provider"
297
            )]
298
        )
299
    ],
300
    name="General Hospital",
301
    contact=[
302
        ExtendedContactDetail(
303
            telecom=[
304
                ContactPoint(
305
                    system="phone",
306
                    value="555-123-4567",
307
                    use="work"
308
                )
309
            ],
310
            address=Address(
311
                line=["123 Hospital Drive"],
312
                city="Medical City",
313
                state="CA",
314
                postalCode="90210"
315
            )
316
        )
317
    ]
318
)
319

320
# Healthcare practitioner
321
practitioner = Practitioner(
322
    active=True,
323
    name=[
324
        HumanName(
325
            use="official",
326
            family="Jones",
327
            given=["Sarah", "M"],
328
            prefix=["Dr."]
329
        )
330
    ],
331
    telecom=[
332
        ContactPoint(
333
            system="phone",
334
            value="555-234-5678",
335
            use="work"
336
        ),
337
        ContactPoint(
338
            system="email",
339
            value="s.jones@hospital.org",
340
            use="work"
341
        )
342
    ],
343
    qualification=[
344
        PractitionerQualification(
345
            code=CodeableConcept(
346
                coding=[Coding(
347
                    system="http://terminology.hl7.org/CodeSystem/v2-0360",
348
                    code="MD",
349
                    display="Doctor of Medicine"
350
                )]
351
            ),
352
            period=Period(start="2010-06-01")
353
        )
354
    ]
355
)
356
```
357

358
### Locations and Healthcare Services
359

360
Physical locations and healthcare services offered within the healthcare system.
361

362
```python { .api }
363
class Location(DomainResource):
364
    """Physical location where services are provided"""
365
    def __init__(
366
        self,
367
        # Core location data
368
        identifier: Optional[List["Identifier"]] = None,
369
        status: Optional[str] = None,  # active | suspended | inactive
370
        operationalStatus: Optional["Coding"] = None,
371
        name: Optional[str] = None,
372
        alias: Optional[List[str]] = None,
373
        description: Optional[str] = None,
374
        mode: Optional[str] = None,  # instance | kind
375
        type: Optional[List["CodeableConcept"]] = None,
376
        
377
        # Contact and address
378
        contact: Optional[List["ExtendedContactDetail"]] = None,
379
        address: Optional["Address"] = None,
380
        form: Optional["CodeableConcept"] = None,
381
        
382
        # Geographical position
383
        position: Optional["LocationPosition"] = None,
384
        
385
        # Organization and management
386
        managingOrganization: Optional["Reference"] = None,
387
        partOf: Optional["Reference"] = None,
388
        characteristic: Optional[List["CodeableConcept"]] = None,
389
        hoursOfOperation: Optional[List["Availability"]] = None,
390
        virtualService: Optional[List["VirtualServiceDetail"]] = None,
391
        endpoint: Optional[List["Reference"]] = None,
392
        
393
        **kwargs
394
    ): ...
395

396
class HealthcareService(DomainResource):
397
    """Details of healthcare service available at location"""
398
    def __init__(
399
        self,
400
        # Core service data
401
        identifier: Optional[List["Identifier"]] = None,
402
        active: Optional[bool] = None,
403
        providedBy: Optional["Reference"] = None,
404
        category: Optional[List["CodeableConcept"]] = None,
405
        type: Optional[List["CodeableConcept"]] = None,
406
        specialty: Optional[List["CodeableConcept"]] = None,
407
        location: Optional[List["Reference"]] = None,
408
        name: Optional[str] = None,
409
        comment: Optional[str] = None,
410
        
411
        # Service details
412
        extraDetails: Optional[str] = None,
413
        photo: Optional["Attachment"] = None,
414
        contact: Optional[List["ExtendedContactDetail"]] = None,
415
        coverageArea: Optional[List["Reference"]] = None,
416
        serviceProvisionCode: Optional[List["CodeableConcept"]] = None,
417
        eligibility: Optional[List["HealthcareServiceEligibility"]] = None,
418
        program: Optional[List["CodeableConcept"]] = None,
419
        characteristic: Optional[List["CodeableConcept"]] = None,
420
        communication: Optional[List["CodeableConcept"]] = None,
421
        referralMethod: Optional[List["CodeableConcept"]] = None,
422
        appointmentRequired: Optional[bool] = None,
423
        availability: Optional[List["Availability"]] = None,
424
        endpoint: Optional[List["Reference"]] = None,
425
        
426
        **kwargs
427
    ): ...
428
```
429

430
## Types
431

432
```python { .api }
433
from typing import Optional, List
434
from fhir.resources.domainresource import DomainResource
435

436
# Administrative resource backbone elements
437
class AppointmentParticipant: ...
438
class AppointmentRecurrenceTemplate: ...
439
class EncounterParticipant: ...
440
class EncounterReason: ...
441
class EncounterDiagnosis: ...
442
class EncounterAdmission: ...
443
class EncounterLocation: ...
444
class OrganizationQualification: ...
445
class PractitionerQualification: ...
446
class PractitionerCommunication: ...
447
class LocationPosition: ...
448
class HealthcareServiceEligibility: ...
449

450
# Complex data types used in administrative resources
451
class ExtendedContactDetail: ...
452
class VirtualServiceDetail: ...
453
class Duration: ...
454
class Availability: ...
455
```