@kernhq/module-hr 0.16.0 → 0.17.0

package/dist/contract/router.d.ts

@@ -38,6 +38,7 @@ export declare const hrContract: {
                 timezone: z.ZodNullable<z.ZodString>;
                 custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                 personnelHidden: z.ZodDefault<z.ZodBoolean>;
+                erasedAt: z.ZodNullable<z.ZodISODateTime>;
                 createdAt: z.ZodISODateTime;
                 updatedAt: z.ZodISODateTime;
                 workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
@@ -93,6 +94,7 @@ export declare const hrContract: {
             timezone: z.ZodNullable<z.ZodString>;
             custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             personnelHidden: z.ZodDefault<z.ZodBoolean>;
+            erasedAt: z.ZodNullable<z.ZodISODateTime>;
             createdAt: z.ZodISODateTime;
             updatedAt: z.ZodISODateTime;
             workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
@@ -149,6 +151,7 @@ export declare const hrContract: {
             timezone: z.ZodNullable<z.ZodString>;
             custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             personnelHidden: z.ZodDefault<z.ZodBoolean>;
+            erasedAt: z.ZodNullable<z.ZodISODateTime>;
             createdAt: z.ZodISODateTime;
             updatedAt: z.ZodISODateTime;
             workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
@@ -215,6 +218,7 @@ export declare const hrContract: {
             timezone: z.ZodNullable<z.ZodString>;
             custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             personnelHidden: z.ZodDefault<z.ZodBoolean>;
+            erasedAt: z.ZodNullable<z.ZodISODateTime>;
             createdAt: z.ZodISODateTime;
             updatedAt: z.ZodISODateTime;
             workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
@@ -272,6 +276,7 @@ export declare const hrContract: {
             timezone: z.ZodNullable<z.ZodString>;
             custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             personnelHidden: z.ZodDefault<z.ZodBoolean>;
+            erasedAt: z.ZodNullable<z.ZodISODateTime>;
             createdAt: z.ZodISODateTime;
             updatedAt: z.ZodISODateTime;
             workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
@@ -325,6 +330,7 @@ export declare const hrContract: {
             timezone: z.ZodNullable<z.ZodString>;
             custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             personnelHidden: z.ZodDefault<z.ZodBoolean>;
+            erasedAt: z.ZodNullable<z.ZodISODateTime>;
             createdAt: z.ZodISODateTime;
             updatedAt: z.ZodISODateTime;
             workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
@@ -1336,6 +1342,7 @@ export declare const hrContract: {
                 timezone: z.ZodNullable<z.ZodString>;
                 custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                 personnelHidden: z.ZodDefault<z.ZodBoolean>;
+                erasedAt: z.ZodNullable<z.ZodISODateTime>;
                 createdAt: z.ZodISODateTime;
                 updatedAt: z.ZodISODateTime;
                 workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
@@ -5898,6 +5905,814 @@ export declare const hrContract: {
             };
         }>, Record<never, never>>;
     };
+    /**
+     * Subject access, erasure and retention. All four behind `hr.privacy.manage`, which is granted to
+     * nobody by default and ships in the same change as these — see `privacy.ts` for why there is one
+     * key rather than four, and why none of this is a capability.
+     */
+    privacy: {
+        /**
+         * Everything HR holds about one person, in one response.
+         *
+         * `personId` is required and there is no filter: a workspace-wide export is two and a half
+         * million rows with decrypted bank details in flight, and it is not offered.
+         *
+         * The decrypt makes this a bulk read of the sensitive record, so it writes a
+         * `sensitive_access_log` row with `via: 'export'` in the same transaction.
+         */
+        subjectAccess: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            personId: z.ZodUUID;
+            purpose: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            manifest: z.ZodObject<{
+                personId: z.ZodUUID;
+                generatedAt: z.ZodISODateTime;
+                generatedBy: z.ZodNullable<z.ZodUUID>;
+                moduleVersion: z.ZodString;
+                truncated: z.ZodArray<z.ZodObject<{
+                    section: z.ZodString;
+                    returned: z.ZodNumber;
+                    cap: z.ZodNumber;
+                }, z.core.$strip>>;
+                excluded: z.ZodArray<z.ZodObject<{
+                    section: z.ZodString;
+                    reason: z.ZodEnum<{
+                        fileContentsNotExportable: "fileContentsNotExportable";
+                        notRequested: "notRequested";
+                    }>;
+                }, z.core.$strip>>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            }, z.core.$strip>;
+            person: z.ZodObject<{
+                userId: z.ZodNullable<z.ZodUUID>;
+                employeeNo: z.ZodNullable<z.ZodString>;
+                displayName: z.ZodString;
+                workEmail: z.ZodNullable<z.ZodEmail>;
+                personalEmail: z.ZodNullable<z.ZodEmail>;
+                phone: z.ZodNullable<z.ZodString>;
+                photoFileId: z.ZodNullable<z.ZodUUID>;
+                status: z.ZodEnum<{
+                    onboarding: "onboarding";
+                    active: "active";
+                    on_leave: "on_leave";
+                    offboarding: "offboarding";
+                    terminated: "terminated";
+                }>;
+                hiredOn: z.ZodNullable<z.ZodISODate>;
+                terminatedOn: z.ZodNullable<z.ZodISODate>;
+                timezone: z.ZodNullable<z.ZodString>;
+                custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                personnelHidden: z.ZodDefault<z.ZodBoolean>;
+                erasedAt: z.ZodNullable<z.ZodISODateTime>;
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, z.core.$strip>;
+            sensitive: z.ZodObject<{
+                nationalId: z.ZodNullable<z.ZodString>;
+                birthDate: z.ZodNullable<z.ZodISODate>;
+                iban: z.ZodNullable<z.ZodString>;
+                emergencyContact: z.ZodNullable<z.ZodObject<{
+                    name: z.ZodString;
+                    relationship: z.ZodOptional<z.ZodString>;
+                    phone: z.ZodString;
+                }, z.core.$strip>>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                personId: z.ZodUUID;
+            }, z.core.$strip>;
+            employment: z.ZodArray<z.ZodObject<{
+                personId: z.ZodUUID;
+                effectiveFrom: z.ZodISODate;
+                effectiveTo: z.ZodNullable<z.ZodISODate>;
+                orgUnitId: z.ZodNullable<z.ZodUUID>;
+                positionId: z.ZodNullable<z.ZodUUID>;
+                legalEntityId: z.ZodNullable<z.ZodUUID>;
+                costCenterId: z.ZodNullable<z.ZodUUID>;
+                managerPersonId: z.ZodNullable<z.ZodUUID>;
+                employmentType: z.ZodEnum<{
+                    full_time: "full_time";
+                    part_time: "part_time";
+                    contract: "contract";
+                    intern: "intern";
+                    temporary: "temporary";
+                    freelance: "freelance";
+                }>;
+                fte: z.ZodNumber;
+                contractHoursWeek: z.ZodNullable<z.ZodNumber>;
+                reason: z.ZodNullable<z.ZodString>;
+                createdAt: z.ZodISODateTime;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, z.core.$strip>>;
+            offices: z.ZodArray<z.ZodObject<{
+                personId: z.ZodUUID;
+                officeId: z.ZodUUID;
+                isPrimary: z.ZodBoolean;
+                effectiveFrom: z.ZodISODate;
+                effectiveTo: z.ZodNullable<z.ZodISODate>;
+                reason: z.ZodNullable<z.ZodString>;
+                createdAt: z.ZodISODateTime;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, z.core.$strip>>;
+            history: z.ZodArray<z.ZodObject<{
+                id: z.ZodUUID;
+                field: z.ZodString;
+                from: z.ZodUnknown;
+                to: z.ZodUnknown;
+                at: z.ZodISODateTime;
+                actorId: z.ZodNullable<z.ZodUUID>;
+                source: z.ZodString;
+            }, z.core.$strip>>;
+            documents: z.ZodArray<z.ZodObject<{
+                personId: z.ZodUUID;
+                fileId: z.ZodUUID;
+                name: z.ZodString;
+                kind: z.ZodString;
+                issuedOn: z.ZodNullable<z.ZodISODate>;
+                expiresOn: z.ZodNullable<z.ZodISODate>;
+                uploadedBy: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodISODateTime;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, z.core.$strip>>;
+            leave: z.ZodObject<{
+                types: z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    name: z.ZodString;
+                    paid: z.ZodBoolean;
+                    unit: z.ZodEnum<{
+                        half_day: "half_day";
+                        day: "day";
+                        hour: "hour";
+                    }>;
+                    color: z.ZodNullable<z.ZodString>;
+                    icon: z.ZodNullable<z.ZodString>;
+                    requiresDocumentAfterDays: z.ZodNullable<z.ZodNumber>;
+                    countsWorkingDaysOnly: z.ZodBoolean;
+                    allowNegative: z.ZodBoolean;
+                    maxNegativeMinutes: z.ZodNumber;
+                    order: z.ZodNumber;
+                    archivedAt: z.ZodNullable<z.ZodISODateTime>;
+                    workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                    id: z.ZodUUID;
+                }, z.core.$strip>>;
+                requests: z.ZodArray<z.ZodObject<{
+                    personId: z.ZodUUID;
+                    leaveTypeId: z.ZodUUID;
+                    startsOn: z.ZodISODate;
+                    endsOn: z.ZodISODate;
+                    startPart: z.ZodEnum<{
+                        full: "full";
+                        morning: "morning";
+                        afternoon: "afternoon";
+                    }>;
+                    endPart: z.ZodEnum<{
+                        full: "full";
+                        morning: "morning";
+                        afternoon: "afternoon";
+                    }>;
+                    hours: z.ZodNullable<z.ZodNumber>;
+                    workingDays: z.ZodNumber;
+                    minutes: z.ZodNumber;
+                    status: z.ZodEnum<{
+                        pending: "pending";
+                        approved: "approved";
+                        rejected: "rejected";
+                        cancelled: "cancelled";
+                        draft: "draft";
+                        withdrawn: "withdrawn";
+                    }>;
+                    reason: z.ZodNullable<z.ZodString>;
+                    documentFileId: z.ZodNullable<z.ZodUUID>;
+                    approvalRequestId: z.ZodNullable<z.ZodUUID>;
+                    decidedAt: z.ZodNullable<z.ZodISODateTime>;
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                    workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                    id: z.ZodUUID;
+                }, z.core.$strip>>;
+                days: z.ZodArray<z.ZodObject<{
+                    id: z.ZodUUID;
+                    requestId: z.ZodUUID;
+                    date: z.ZodISODate;
+                    fraction: z.ZodNumber;
+                    counted: z.ZodBoolean;
+                    status: z.ZodString;
+                }, z.core.$strip>>;
+                ledger: z.ZodArray<z.ZodObject<{
+                    personId: z.ZodUUID;
+                    leaveTypeId: z.ZodUUID;
+                    kind: z.ZodEnum<{
+                        grant: "grant";
+                        accrual: "accrual";
+                        consumption: "consumption";
+                        reversal: "reversal";
+                        expiry: "expiry";
+                        adjustment: "adjustment";
+                        carry_in: "carry_in";
+                        carry_out: "carry_out";
+                        encashment: "encashment";
+                    }>;
+                    amountMinutes: z.ZodNumber;
+                    effectiveOn: z.ZodISODate;
+                    periodYear: z.ZodNumber;
+                    requestId: z.ZodNullable<z.ZodUUID>;
+                    reversesEntryId: z.ZodNullable<z.ZodUUID>;
+                    policyHash: z.ZodNullable<z.ZodString>;
+                    reason: z.ZodNullable<z.ZodString>;
+                    createdBy: z.ZodNullable<z.ZodUUID>;
+                    createdAt: z.ZodISODateTime;
+                    workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                    id: z.ZodUUID;
+                }, z.core.$strip>>;
+                closingBalanceMinutes: z.ZodNumber;
+            }, z.core.$strip>;
+            attendance: z.ZodObject<{
+                punches: z.ZodArray<z.ZodObject<{
+                    personId: z.ZodUUID;
+                    direction: z.ZodEnum<{
+                        out: "out";
+                        in: "in";
+                        break_start: "break_start";
+                        break_end: "break_end";
+                    }>;
+                    at: z.ZodISODateTime;
+                    clientReportedAt: z.ZodNullable<z.ZodISODateTime>;
+                    skewMs: z.ZodNullable<z.ZodNumber>;
+                    businessDate: z.ZodISODate;
+                    timezone: z.ZodString;
+                    method: z.ZodEnum<{
+                        web: "web";
+                        mobile: "mobile";
+                        kiosk: "kiosk";
+                        qr: "qr";
+                        device: "device";
+                        import: "import";
+                        manual: "manual";
+                        auto: "auto";
+                    }>;
+                    officeId: z.ZodNullable<z.ZodUUID>;
+                    deviceId: z.ZodNullable<z.ZodUUID>;
+                    geo: z.ZodNullable<z.ZodObject<{
+                        lat: z.ZodNumber;
+                        lng: z.ZodNumber;
+                        accuracyM: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                    trust: z.ZodEnum<{
+                        trusted: "trusted";
+                        claimed: "claimed";
+                        disputed: "disputed";
+                    }>;
+                    voidedByPunchId: z.ZodNullable<z.ZodUUID>;
+                    note: z.ZodNullable<z.ZodString>;
+                    createdAt: z.ZodISODateTime;
+                    workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                    id: z.ZodUUID;
+                }, z.core.$strip>>;
+                days: z.ZodArray<z.ZodObject<{
+                    personId: z.ZodUUID;
+                    businessDate: z.ZodISODate;
+                    scheduledMinutes: z.ZodNumber;
+                    workedMinutes: z.ZodNumber;
+                    breakMinutes: z.ZodNumber;
+                    overtimeMinutes: z.ZodNumber;
+                    beyondCapMinutes: z.ZodNullable<z.ZodNumber>;
+                    lateMinutes: z.ZodNumber;
+                    earlyLeaveMinutes: z.ZodNumber;
+                    status: z.ZodEnum<{
+                        leave: "leave";
+                        pending: "pending";
+                        present: "present";
+                        absent: "absent";
+                        holiday: "holiday";
+                        weekend: "weekend";
+                        partial: "partial";
+                    }>;
+                    leaveRequestId: z.ZodNullable<z.ZodUUID>;
+                    anomalies: z.ZodArray<z.ZodString>;
+                    firstIn: z.ZodNullable<z.ZodISODateTime>;
+                    lastOut: z.ZodNullable<z.ZodISODateTime>;
+                    policyHash: z.ZodNullable<z.ZodString>;
+                    locked: z.ZodBoolean;
+                    computedAt: z.ZodISODateTime;
+                    workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                    id: z.ZodUUID;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            regularizations: z.ZodArray<z.ZodObject<{
+                personId: z.ZodUUID;
+                businessDate: z.ZodISODate;
+                punchId: z.ZodNullable<z.ZodUUID>;
+                proposed: z.ZodArray<z.ZodObject<{
+                    direction: z.ZodEnum<{
+                        out: "out";
+                        in: "in";
+                        break_start: "break_start";
+                        break_end: "break_end";
+                    }>;
+                    at: z.ZodISODateTime;
+                }, z.core.$strip>>;
+                reason: z.ZodString;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    approved: "approved";
+                    rejected: "rejected";
+                    cancelled: "cancelled";
+                }>;
+                approvalRequestId: z.ZodNullable<z.ZodUUID>;
+                appliedAt: z.ZodNullable<z.ZodISODateTime>;
+                createdAt: z.ZodISODateTime;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, z.core.$strip>>;
+            approvals: z.ZodObject<{
+                raised: z.ZodArray<z.ZodObject<{
+                    subjectType: z.ZodEnum<{
+                        leave: "leave";
+                        regularization: "regularization";
+                        overtime: "overtime";
+                        timesheet: "timesheet";
+                        shift_swap: "shift_swap";
+                    }>;
+                    subjectId: z.ZodUUID;
+                    summary: z.ZodString;
+                    summaryParams: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+                    status: z.ZodEnum<{
+                        pending: "pending";
+                        approved: "approved";
+                        rejected: "rejected";
+                        cancelled: "cancelled";
+                    }>;
+                    currentStep: z.ZodNumber;
+                    requestedBy: z.ZodNullable<z.ZodUUID>;
+                    requesterPersonId: z.ZodNullable<z.ZodUUID>;
+                    requesterName: z.ZodNullable<z.ZodString>;
+                    requestedAt: z.ZodISODateTime;
+                    decidedAt: z.ZodNullable<z.ZodISODateTime>;
+                    steps: z.ZodArray<z.ZodObject<{
+                        id: z.ZodUUID;
+                        requestId: z.ZodUUID;
+                        stepIndex: z.ZodNumber;
+                        name: z.ZodString;
+                        mode: z.ZodEnum<{
+                            any: "any";
+                            all: "all";
+                            quorum: "quorum";
+                        }>;
+                        minApprovals: z.ZodNumber;
+                        approverIds: z.ZodArray<z.ZodUUID>;
+                        status: z.ZodEnum<{
+                            pending: "pending";
+                            approved: "approved";
+                            rejected: "rejected";
+                            cancelled: "cancelled";
+                        }>;
+                        dueAt: z.ZodNullable<z.ZodISODateTime>;
+                        escalatedAt: z.ZodNullable<z.ZodISODateTime>;
+                        decisions: z.ZodArray<z.ZodObject<{
+                            id: z.ZodUUID;
+                            stepId: z.ZodUUID;
+                            approverId: z.ZodUUID;
+                            onBehalfOfId: z.ZodNullable<z.ZodUUID>;
+                            decision: z.ZodEnum<{
+                                approve: "approve";
+                                reject: "reject";
+                            }>;
+                            comment: z.ZodNullable<z.ZodString>;
+                            at: z.ZodISODateTime;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                    workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                    id: z.ZodUUID;
+                }, z.core.$strip>>;
+                approverOn: z.ZodArray<z.ZodObject<{
+                    id: z.ZodUUID;
+                    requestId: z.ZodUUID;
+                    stepIndex: z.ZodNumber;
+                    name: z.ZodString;
+                    mode: z.ZodEnum<{
+                        any: "any";
+                        all: "all";
+                        quorum: "quorum";
+                    }>;
+                    minApprovals: z.ZodNumber;
+                    approverIds: z.ZodArray<z.ZodUUID>;
+                    status: z.ZodEnum<{
+                        pending: "pending";
+                        approved: "approved";
+                        rejected: "rejected";
+                        cancelled: "cancelled";
+                    }>;
+                    dueAt: z.ZodNullable<z.ZodISODateTime>;
+                    escalatedAt: z.ZodNullable<z.ZodISODateTime>;
+                    decisions: z.ZodArray<z.ZodObject<{
+                        id: z.ZodUUID;
+                        stepId: z.ZodUUID;
+                        approverId: z.ZodUUID;
+                        onBehalfOfId: z.ZodNullable<z.ZodUUID>;
+                        decision: z.ZodEnum<{
+                            approve: "approve";
+                            reject: "reject";
+                        }>;
+                        comment: z.ZodNullable<z.ZodString>;
+                        at: z.ZodISODateTime;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                decisions: z.ZodArray<z.ZodObject<{
+                    id: z.ZodUUID;
+                    stepId: z.ZodUUID;
+                    approverId: z.ZodUUID;
+                    onBehalfOfId: z.ZodNullable<z.ZodUUID>;
+                    decision: z.ZodEnum<{
+                        approve: "approve";
+                        reject: "reject";
+                    }>;
+                    comment: z.ZodNullable<z.ZodString>;
+                    at: z.ZodISODateTime;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            delegations: z.ZodObject<{
+                given: z.ZodArray<z.ZodObject<{
+                    fromPersonId: z.ZodUUID;
+                    toPersonId: z.ZodUUID;
+                    subjectType: z.ZodNullable<z.ZodEnum<{
+                        leave: "leave";
+                        regularization: "regularization";
+                        overtime: "overtime";
+                        timesheet: "timesheet";
+                        shift_swap: "shift_swap";
+                    }>>;
+                    startsOn: z.ZodISODate;
+                    endsOn: z.ZodISODate;
+                    reason: z.ZodNullable<z.ZodString>;
+                    createdAt: z.ZodISODateTime;
+                    workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                    id: z.ZodUUID;
+                }, z.core.$strip>>;
+                received: z.ZodArray<z.ZodObject<{
+                    fromPersonId: z.ZodUUID;
+                    toPersonId: z.ZodUUID;
+                    subjectType: z.ZodNullable<z.ZodEnum<{
+                        leave: "leave";
+                        regularization: "regularization";
+                        overtime: "overtime";
+                        timesheet: "timesheet";
+                        shift_swap: "shift_swap";
+                    }>>;
+                    startsOn: z.ZodISODate;
+                    endsOn: z.ZodISODate;
+                    reason: z.ZodNullable<z.ZodString>;
+                    createdAt: z.ZodISODateTime;
+                    workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                    id: z.ZodUUID;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            policiesInForce: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    overtime: "overtime";
+                    accrual: "accrual";
+                    carry_forward: "carry_forward";
+                    rounding: "rounding";
+                    working_time: "working_time";
+                }>;
+                policyId: z.ZodNullable<z.ZodUUID>;
+                policyName: z.ZodNullable<z.ZodString>;
+                config: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                from: z.ZodNullable<z.ZodEnum<{
+                    person: "person";
+                    office: "office";
+                    legal_entity: "legal_entity";
+                    org_unit: "org_unit";
+                    position: "position";
+                    workspace: "workspace";
+                }>>;
+                fromSubjectId: z.ZodNullable<z.ZodUUID>;
+            }, z.core.$strip>>;
+            accessLog: z.ZodArray<z.ZodObject<{
+                id: z.ZodUUID;
+                personId: z.ZodUUID;
+                actorUserId: z.ZodUUID;
+                actorPersonId: z.ZodNullable<z.ZodUUID>;
+                fields: z.ZodArray<z.ZodString>;
+                purpose: z.ZodNullable<z.ZodString>;
+                via: z.ZodEnum<{
+                    ui: "ui";
+                    api: "api";
+                    export: "export";
+                }>;
+                at: z.ZodISODateTime;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            BAD_REQUEST: {
+                data: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            };
+            UNAUTHORIZED: {};
+            FORBIDDEN: {
+                data: z.ZodOptional<z.ZodObject<{
+                    permission: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            };
+            NOT_FOUND: {};
+            CONFLICT: {
+                data: z.ZodOptional<z.ZodObject<{
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            };
+            RATE_LIMITED: {};
+            MODULE_DISABLED: {
+                data: z.ZodObject<{
+                    module: z.ZodString;
+                }, z.core.$strip>;
+            };
+        }>, Record<never, never>>;
+        /**
+         * Redact a person, and say what survived.
+         *
+         * **`dryRun` defaults to true**, which is the opposite of every other write in this module and
+         * deliberate. This is the one irreversible act HR offers, so a caller that forgets the flag has
+         * to get the preview rather than the erasure. It matters more than it reads: core generates an
+         * MCP tool from every hosted module's OpenAPI document, so a procedure with a REST route is
+         * agent-callable the day it ships, and the call made with no arguments has to be the harmless
+         * one. The preview runs the same predicates the run does and returns the same shape.
+         *
+         * Nothing is deleted. The identifying columns are cleared and every record a wage, an
+         * entitlement or an authorisation was computed from stays, listed in `kept` with the basis it
+         * survived under. Running it twice is safe and reports zero rows the second time: each step
+         * matches only rows that still have something to clear.
+         */
+        erase: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            personId: z.ZodUUID;
+            dryRun: z.ZodDefault<z.ZodBoolean>;
+            reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            keepNationalIdForAudit: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            personId: z.ZodUUID;
+            dryRun: z.ZodBoolean;
+            erasedAt: z.ZodNullable<z.ZodISODateTime>;
+            displayName: z.ZodString;
+            redacted: z.ZodArray<z.ZodObject<{
+                class: z.ZodEnum<{
+                    sensitive: "sensitive";
+                    employment: "employment";
+                    approvals: "approvals";
+                    attendance: "attendance";
+                    documents: "documents";
+                    punches: "punches";
+                    identity: "identity";
+                    history: "history";
+                    leaveRequests: "leaveRequests";
+                    leaveLedger: "leaveLedger";
+                    officeAssignments: "officeAssignments";
+                    approvalDecisions: "approvalDecisions";
+                    regularizations: "regularizations";
+                    delegations: "delegations";
+                    headship: "headship";
+                }>;
+                table: z.ZodString;
+                rows: z.ZodNumber;
+                columns: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            kept: z.ZodArray<z.ZodObject<{
+                class: z.ZodEnum<{
+                    sensitive: "sensitive";
+                    employment: "employment";
+                    approvals: "approvals";
+                    attendance: "attendance";
+                    documents: "documents";
+                    punches: "punches";
+                    identity: "identity";
+                    history: "history";
+                    leaveRequests: "leaveRequests";
+                    leaveLedger: "leaveLedger";
+                    officeAssignments: "officeAssignments";
+                    approvalDecisions: "approvalDecisions";
+                    regularizations: "regularizations";
+                    delegations: "delegations";
+                    headship: "headship";
+                }>;
+                table: z.ZodString;
+                rows: z.ZodNumber;
+                basis: z.ZodEnum<{
+                    payRecord: "payRecord";
+                    auditTrail: "auditTrail";
+                    retentionHorizon: "retentionHorizon";
+                    notRemovable: "notRemovable";
+                    anotherPersonsRecord: "anotherPersonsRecord";
+                }>;
+                retentionDays: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+            caveats: z.ZodArray<z.ZodEnum<{
+                documentFilesRemain: "documentFilesRemain";
+                photoFileOrphaned: "photoFileOrphaned";
+                leaveDocumentFilesRemain: "leaveDocumentFilesRemain";
+                nationalIdKeptForAudit: "nationalIdKeptForAudit";
+                actorHistoryKept: "actorHistoryKept";
+                lockedPeriodUntouched: "lockedPeriodUntouched";
+            }>>;
+            filesRemaining: z.ZodArray<z.ZodUUID>;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            BAD_REQUEST: {
+                data: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            };
+            UNAUTHORIZED: {};
+            FORBIDDEN: {
+                data: z.ZodOptional<z.ZodObject<{
+                    permission: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            };
+            NOT_FOUND: {};
+            CONFLICT: {
+                data: z.ZodOptional<z.ZodObject<{
+                    reason: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            };
+            RATE_LIMITED: {};
+            MODULE_DISABLED: {
+                data: z.ZodObject<{
+                    module: z.ZodString;
+                }, z.core.$strip>;
+            };
+        }>, Record<never, never>>;
+        /**
+         * Who read somebody's identity, birth date or bank details.
+         *
+         * **About yourself this carries no permission**, which is why it has no `requires()` and sits in
+         * `module.test.ts`'s `SELF_SERVICE` allowlist. Reading your own access log is a thing nobody may
+         * lack, exactly like `people.me`; a grantable key here could only ever be one somebody could be
+         * denied, and being denied sight of who has been looking at your bank details is not a state
+         * this product should be able to express.
+         *
+         * About anybody else it needs `hr.privacy.manage`, and the handler is what asks — a `personId`
+         * that is not the caller's own, or an `actorUserId` at all. The second is not a smaller question
+         * than the first: "what has this account been looking at" is an investigation into a colleague,
+         * and it is the query that makes this log something to be careful with rather than only
+         * something to be reassured by.
+         */
+        accessLog: {
+            list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                personId: z.ZodOptional<z.ZodUUID>;
+                actorUserId: z.ZodOptional<z.ZodUUID>;
+                cursor: z.ZodOptional<z.ZodString>;
+                limit: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>, z.ZodObject<{
+                items: z.ZodArray<z.ZodObject<{
+                    id: z.ZodUUID;
+                    personId: z.ZodUUID;
+                    actorUserId: z.ZodUUID;
+                    actorPersonId: z.ZodNullable<z.ZodUUID>;
+                    fields: z.ZodArray<z.ZodString>;
+                    purpose: z.ZodNullable<z.ZodString>;
+                    via: z.ZodEnum<{
+                        ui: "ui";
+                        api: "api";
+                        export: "export";
+                    }>;
+                    at: z.ZodISODateTime;
+                }, z.core.$strip>>;
+                nextCursor: z.ZodNullable<z.ZodString>;
+                total: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+                BAD_REQUEST: {
+                    data: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+                };
+                UNAUTHORIZED: {};
+                FORBIDDEN: {
+                    data: z.ZodOptional<z.ZodObject<{
+                        permission: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                };
+                NOT_FOUND: {};
+                CONFLICT: {
+                    data: z.ZodOptional<z.ZodObject<{
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                };
+                RATE_LIMITED: {};
+                MODULE_DISABLED: {
+                    data: z.ZodObject<{
+                        module: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            }>, Record<never, never>>;
+        };
+        retention: {
+            /**
+             * The horizons, and — with `withCounts` — how much is already past each one.
+             *
+             * The counts are the dry run. They cost a query per class that has a horizon set, so they are
+             * asked for rather than always computed; a retention screen should ask for them.
+             */
+            get: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                withCounts: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                classes: z.ZodArray<z.ZodObject<{
+                    class: z.ZodEnum<{
+                        leave: "leave";
+                        punchDetail: "punchDetail";
+                        punches: "punches";
+                        attendanceDays: "attendanceDays";
+                        personHistory: "personHistory";
+                        personDocuments: "personDocuments";
+                        terminatedPeople: "terminatedPeople";
+                        sensitiveAccessLog: "sensitiveAccessLog";
+                    }>;
+                    days: z.ZodNullable<z.ZodNumber>;
+                    dueNow: z.ZodNullable<z.ZodNumber>;
+                }, z.core.$strip>>;
+                updatedAt: z.ZodNullable<z.ZodISODateTime>;
+                updatedBy: z.ZodNullable<z.ZodUUID>;
+                sweepEnabled: z.ZodLiteral<false>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+                BAD_REQUEST: {
+                    data: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+                };
+                UNAUTHORIZED: {};
+                FORBIDDEN: {
+                    data: z.ZodOptional<z.ZodObject<{
+                        permission: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                };
+                NOT_FOUND: {};
+                CONFLICT: {
+                    data: z.ZodOptional<z.ZodObject<{
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                };
+                RATE_LIMITED: {};
+                MODULE_DISABLED: {
+                    data: z.ZodObject<{
+                        module: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            }>, Record<never, never>>;
+            /**
+             * Set them. A field left out is unchanged; a field sent as `null` goes back to "keep
+             * indefinitely", which is what every class ships as.
+             */
+            set: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                retention: z.ZodObject<{
+                    punchDetail: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodNumber>>>;
+                    punches: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodNumber>>>;
+                    attendanceDays: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodNumber>>>;
+                    leave: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodNumber>>>;
+                    personHistory: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodNumber>>>;
+                    personDocuments: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodNumber>>>;
+                    terminatedPeople: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodNumber>>>;
+                    sensitiveAccessLog: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodNumber>>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                classes: z.ZodArray<z.ZodObject<{
+                    class: z.ZodEnum<{
+                        leave: "leave";
+                        punchDetail: "punchDetail";
+                        punches: "punches";
+                        attendanceDays: "attendanceDays";
+                        personHistory: "personHistory";
+                        personDocuments: "personDocuments";
+                        terminatedPeople: "terminatedPeople";
+                        sensitiveAccessLog: "sensitiveAccessLog";
+                    }>;
+                    days: z.ZodNullable<z.ZodNumber>;
+                    dueNow: z.ZodNullable<z.ZodNumber>;
+                }, z.core.$strip>>;
+                updatedAt: z.ZodNullable<z.ZodISODateTime>;
+                updatedBy: z.ZodNullable<z.ZodUUID>;
+                sweepEnabled: z.ZodLiteral<false>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+                BAD_REQUEST: {
+                    data: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+                };
+                UNAUTHORIZED: {};
+                FORBIDDEN: {
+                    data: z.ZodOptional<z.ZodObject<{
+                        permission: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                };
+                NOT_FOUND: {};
+                CONFLICT: {
+                    data: z.ZodOptional<z.ZodObject<{
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                };
+                RATE_LIMITED: {};
+                MODULE_DISABLED: {
+                    data: z.ZodObject<{
+                        module: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            }>, Record<never, never>>;
+        };
+    };
 };
 export type HrContract = typeof hrContract;
 //# sourceMappingURL=router.d.ts.map