> ## Documentation Index
> Fetch the complete documentation index at: https://proxy-docs.permify.co/llms.txt
> Use this file to discover all available pages before exploring further.

# Healthcare System

This example represents a healthcare company permission system where users, such as doctors, patients, and administrators, have fine-grained access to medical records, appointments, and patient management.

## Schema

```permify theme={null}
entity user {}

entity doctor {
    // Doctors can have multiple patients.
    relation patient @patient
    relation group @group
}

entity partner {
    relation admin @user
    relation member @user

    permission edit = admin
    permission view = edit or member
}

entity group {
    relation partner @partner
    relation doctor @doctor

    permission edit = partner.edit or doctor
    permission view = edit or partner.view
}

entity patient {
    // Patients can have multiple doctors and be linked to groups.
    relation primary_doctor @doctor
    relation consultant @doctor
    relation group @group
    relation owner @user
    relation guardian @user

    attribute age integer

    // Permissions for accessing patient data.
    permission parent_access = check_age(age)
    permission edit = owner or group.edit or primary_doctor or consultant
    permission view = edit or group.view or guardian
}

rule check_age(age integer) {
    age < 18
}

entity medical_record {
    // Each medical record pertains to a patient and a doctor.
    relation patient @patient
    relation doctor @doctor

    // Permissions for medical record access.
    action view = doctor.patient or patient or patient.guardian
    action create = doctor.patient
    action update = doctor.patient
    action delete = doctor.patient
}

entity hospital {
    // Hospitals can have doctors, patients, and groups.
    relation doctor @doctor
    relation patient @patient
    relation group @group

    // Actions for managing hospital processes.
    action admit_patient = doctor
    action discharge_patient = doctor
    action view_patient_records = doctor or patient.guardian or group.view
}

entity appointment {
    // Appointments link a patient with a doctor.
    relation doctor @doctor
    relation patient @patient

    // Patients or doctors can manage appointments.
    action create = patient or doctor
    action update = patient or doctor.patient
    action delete = doctor.patient
}

entity claims {
    // Claims link a patient with a group and can involve multiple entities.
    relation group @group
    relation patient @patient

    action edit = patient.edit or group.edit
    action view = edit or patient.view or group.view
    action parent_access = patient.parent_access
}
```

Here’s a breakdown of the combined schema, explaining each part and how it functions according to the Permify Schema Language:

### 1. `entity user {}`

* **Entity**: Represents a user in the system.
* **Explanation**: This entity is a placeholder for individual users. In other relationships, users are assigned roles or permissions based on their connections to other entities.

### 2. `entity doctor { ... }`

* **Relations**:
  * `relation patient @patient`: Doctors can be associated with multiple patients.
  * `relation group @group`: Doctors can also be linked to groups (e.g., medical teams or departments).
* **Explanation**: The `doctor` entity models a healthcare professional who can have multiple patients assigned to them and can belong to groups. Relationships help manage permissions for accessing patient-related data or participating in group-based activities.

### 3. `entity partner { ... }`

* **Relations**:
  * `relation admin @user`: The admin of the partner is a user.
  * `relation member @user`: Members of the partner are also users.
* **Permissions**:
  * `permission edit = admin`: Users who are admins can edit.
  * `permission view = edit or member`: Members can view, and admins have inherited view access from the edit permission.
* **Explanation**: This entity represents a partner organization, with roles for admin and member users. It defines permissions for actions like editing or viewing the partner data based on user roles.

### 4. `entity group { ... }`

* **Relations**:
  * `relation partner @partner`: A group is associated with a partner.
  * `relation doctor @doctor`: Groups can include doctors.
* **Permissions**:
  * `permission edit = partner.edit or doctor`: If a partner has edit access, or if a doctor is linked, then the group can be edited.
  * `permission view = edit or partner.view`: The view permission is granted if a user has edit access or if the partner can view.
* **Explanation**: Groups are collections that can include doctors and be tied to partners. This entity manages permissions for actions within the group, such as editing or viewing.

### 5. `entity patient { ... }`

* **Relations**:
  * `relation primary_doctor @doctor`: A patient has a primary doctor.
  * `relation consultant @doctor`: A patient can have consultant doctors.
  * `relation group @group`: Patients can be linked to groups (e.g., departments).
  * `relation owner @user`: An owner (usually a guardian or caregiver) is associated with the patient.
  * `relation guardian @user`: A guardian can also be linked to a patient.
* **Attributes**:
  * `attribute age integer`: Represents the patient's age.
* **Permissions**:
  * `permission parent_access = check_age(age)`: The permission for parent access is granted when the schema-level `check_age` rule evaluates true for underage patients.
  * `permission edit = owner or group.edit or primary_doctor or consultant`: Editing permissions are granted to the owner, group members with edit rights, or the doctors.
  * `permission view = edit or group.view or guardian`: View permissions extend to anyone who can edit, group members who can view, or the guardian.
* **Explanation**: This entity models patients and defines relationships with doctors, groups, and guardians. Permissions are fine-grained, including a simple age-based rule for underage access.

### 6. `rule check_age(age integer)`

* **Rule**:
  * `rule check_age(age integer) { age < 18 }`: This rule evaluates an age-based condition and returns a boolean result.
* **Explanation**: In Permify, rules are schema-level definitions that evaluate conditions and return a boolean result. This rule is used to determine whether a patient qualifies for age-based access.

### 7. `entity medical_record { ... }`

* **Relations**:
  * `relation patient @patient`: Links the medical record to a patient.
  * `relation doctor @doctor`: Associates the medical record with a doctor.
* **Actions**:
  * `action view = doctor.patient or patient or patient.guardian`: The record can be viewed by doctors associated with the patient, the patient themselves, or their guardian.
  * `action create = doctor.patient`: Only doctors who are associated with the patient can create the record.
  * `action update = doctor.patient`: Updating the record is limited to the patient’s doctor.
  * `action delete = doctor.patient`: Deleting the record is also restricted to the doctor.
* **Explanation**: This entity models medical records and enforces strict access control based on the doctor-patient relationship, with different permissions for viewing, creating, updating, and deleting records.

### 8. `entity hospital { ... }`

* **Relations**:
  * `relation doctor @doctor`: Doctors associated with the hospital.
  * `relation patient @patient`: Patients associated with the hospital.
  * `relation group @group`: Groups linked to the hospital (e.g., medical departments).
* **Actions**:
  * `action admit_patient = doctor`: Doctors can admit patients.
  * `action discharge_patient = doctor`: Doctors can discharge patients.
  * `action view_patient_records = doctor or patient.guardian or group.view`: Allows doctors, patient guardians, or group members with view access to see patient records.
* **Explanation**: This entity represents hospitals, with relationships to doctors, patients, and groups. The actions define what activities doctors can perform, such as admitting or discharging patients.

### 9. `entity appointment { ... }`

* **Relations**:
  * `relation doctor @doctor`: Associates the appointment with a doctor.
  * `relation patient @patient`: Associates the appointment with a patient.
* **Actions**:
  * `action create = patient or doctor`: Both patients and doctors can create appointments.
  * `action update = patient or doctor.patient`: Either the patient or their associated doctor can update the appointment.
  * `action delete = doctor.patient`: Only doctors associated with the patient can delete the appointment.
* **Explanation**: The `appointment` entity handles scheduling activities, linking patients with doctors and defining who can create, update, or delete appointments.

### 10. `entity claims { ... }`

* **Relations**:
  * `relation group @group`: Claims can be linked to a group.
  * `relation patient @patient`: Claims can be associated with a patient.
* **Actions**:
  * `action edit = patient.edit or group.edit`: Claims can be edited by those with patient edit permissions or group edit permissions.
  * `action view = edit or patient.view or group.view`: View permissions are granted to those who can edit or have patient or group view permissions.
  * `action parent_access = patient.parent_access`: Parent access to claims follows the parent access permissions for the patient.
* **Explanation**: This entity models claims related to patients and groups, defining how these claims can be accessed or modified.