@kernhq/module-hr 0.15.0 → 0.17.0

package/dist/contract/privacy.d.ts

@@ -0,0 +1,860 @@
+import { z } from 'zod';
+/**
+ * The classes retention is expressed in.
+ *
+ * They follow the redact/retain split rather than the table list, because that is the split a
+ * retention decision is actually made in: "how long do we keep the evidence behind a day sheet" is
+ * one question whatever tables it lands in.
+ */
+export declare const RetentionClass: z.ZodEnum<{
+    leave: "leave";
+    punchDetail: "punchDetail";
+    punches: "punches";
+    attendanceDays: "attendanceDays";
+    personHistory: "personHistory";
+    personDocuments: "personDocuments";
+    terminatedPeople: "terminatedPeople";
+    sensitiveAccessLog: "sensitiveAccessLog";
+}>;
+export type RetentionClass = z.infer<typeof RetentionClass>;
+/**
+ * How long HR keeps each class, per workspace.
+ *
+ * A table rather than module settings, and the reason is mechanical: `core.settings.setModule`
+ * validates the merged blob against the module's declared zod schema and a zod object strips what it
+ * does not declare — so a retention key stored beside `country` and `employeeNumberPrefix` would be
+ * deleted by the next unrelated settings write, silently, from a screen that never mentions
+ * retention. Extending `HrSettings` instead is the other honest route and is a change to a shared
+ * shape; this one keeps the numbers where nothing can quietly drop them.
+ *
+ * Workspace-wide for now. The honest end state is per legal entity — a Dutch entity and a Turkish
+ * one have different obligations, which is exactly why `periods` is already per legal entity — and
+ * the row carries a jsonb config so that move is an added column rather than a new table.
+ */
+export declare const HrRetention: z.ZodObject<{
+    punchDetail: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    punches: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    attendanceDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    leave: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    personHistory: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    personDocuments: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    terminatedPeople: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    sensitiveAccessLog: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type HrRetention = z.infer<typeof HrRetention>;
+/** One class, its horizon, and what has already passed it. */
+export declare const RetentionClassState: 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>;
+export type RetentionClassState = z.infer<typeof RetentionClassState>;
+export declare const RetentionSettings: 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>;
+export type RetentionSettings = z.infer<typeof RetentionSettings>;
+/** The units erasure reports in. One per group of columns that survive or go together. */
+export declare const ErasureClass: 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";
+}>;
+export type ErasureClass = z.infer<typeof ErasureClass>;
+/** A class the erasure cleared, and exactly which columns it cleared. */
+export declare const ErasureRedaction: 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>;
+export type ErasureRedaction = z.infer<typeof ErasureRedaction>;
+/**
+ * Why a record survived an erasure.
+ *
+ * An enum rather than a sentence: a reason composed on the server is English for every reader, and
+ * this one is read by the person who asked to be forgotten. The client renders it.
+ */
+export declare const RetentionBasis: z.ZodEnum<{
+    payRecord: "payRecord";
+    auditTrail: "auditTrail";
+    retentionHorizon: "retentionHorizon";
+    notRemovable: "notRemovable";
+    anotherPersonsRecord: "anotherPersonsRecord";
+}>;
+export type RetentionBasis = z.infer<typeof RetentionBasis>;
+export declare const ErasureRetained: 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>;
+export type ErasureRetained = z.infer<typeof ErasureRetained>;
+/**
+ * Things the response has to state in words, as keys the client renders.
+ *
+ * Each one is a promise this module would otherwise be making and not keeping.
+ */
+export declare const ErasureCaveat: z.ZodEnum<{
+    documentFilesRemain: "documentFilesRemain";
+    photoFileOrphaned: "photoFileOrphaned";
+    leaveDocumentFilesRemain: "leaveDocumentFilesRemain";
+    nationalIdKeptForAudit: "nationalIdKeptForAudit";
+    actorHistoryKept: "actorHistoryKept";
+    lockedPeriodUntouched: "lockedPeriodUntouched";
+}>;
+export type ErasureCaveat = z.infer<typeof ErasureCaveat>;
+/**
+ * What an erasure did, or would do.
+ *
+ * The same shape either way, because a preview computed differently from the thing it previews is a
+ * preview that eventually lies — the rule `accrual.preview` is written under.
+ */
+export declare const ErasureReport: 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>;
+export type ErasureReport = z.infer<typeof ErasureReport>;
+/**
+ * How a sensitive record was reached.
+ *
+ * Derived from the principal, never taken from the caller — a client-supplied value is one the
+ * reader controls, and this log exists to say what happened rather than what the reader claimed.
+ * `export` is the exception and is not reachable from a request: it is passed by the one server-side
+ * path that takes a bulk copy of a record, which is `privacy.subjectAccess`.
+ *
+ * There is no `mcp` and no `service`, and both omissions are the same rule rather than an oversight.
+ * Core's MCP proxy forwards a plain bearer token, so an assistant's read arrives as an ordinary
+ * `kind: 'user'` principal that nothing here can honestly tell from a browser; and a service
+ * principal carries no user id at all, so the read is refused before a row is built. A value nothing
+ * can ever write is the same lie as a permission key nothing asks about. See `services/audit.ts`.
+ */
+export declare const SensitiveAccessVia: z.ZodEnum<{
+    ui: "ui";
+    api: "api";
+    export: "export";
+}>;
+export type SensitiveAccessVia = z.infer<typeof SensitiveAccessVia>;
+/**
+ * One read of somebody's identity, birth date or bank details.
+ *
+ * Written in the same transaction as the read, in HR's own schema. `mod_core.activity_events` also
+ * gets a best-effort copy so the workspace's single audit console shows that HR sensitive data was
+ * touched — but it cannot be the record, for two reasons: it is read behind `core.audit.view`,
+ * which owners and admins hold by default and `hr.person.view_sensitive` deliberately nobody does,
+ * so publishing the read there inverts the model the sensitive split exists to create; and the
+ * cross-service call is allowed to fail, which is right for a notification and wrong for evidence.
+ * A subject-access response that answers "who looked at my data" out of a log with silent holes is
+ * worse than one that says it cannot answer.
+ */
+export declare const SensitiveAccess: 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>;
+export type SensitiveAccess = z.infer<typeof SensitiveAccess>;
+/** `person_history`, with the values. Redacting it in a subject's own bundle defeats the purpose. */
+export declare const PersonHistoryEntry: 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>;
+export type PersonHistoryEntry = z.infer<typeof PersonHistoryEntry>;
+/** A request exploded into days — what the balance was actually charged for. */
+export declare const LeaveRequestDay: z.ZodObject<{
+    id: z.ZodUUID;
+    requestId: z.ZodUUID;
+    date: z.ZodISODate;
+    fraction: z.ZodNumber;
+    counted: z.ZodBoolean;
+    status: z.ZodString;
+}, z.core.$strip>;
+export type LeaveRequestDay = z.infer<typeof LeaveRequestDay>;
+/** A section that hit the row cap. Named, with its numbers, so nothing is short by surprise. */
+export declare const BundleTruncation: z.ZodObject<{
+    section: z.ZodString;
+    returned: z.ZodNumber;
+    cap: z.ZodNumber;
+}, z.core.$strip>;
+/** Something this bundle does not contain, and why. */
+export declare const BundleExclusion: z.ZodObject<{
+    section: z.ZodString;
+    reason: z.ZodEnum<{
+        fileContentsNotExportable: "fileContentsNotExportable";
+        notRequested: "notRequested";
+    }>;
+}, z.core.$strip>;
+export declare const SubjectAccessManifest: 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>;
+export type SubjectAccessManifest = z.infer<typeof SubjectAccessManifest>;
+/**
+ * Everything HR holds about one person, including the parts they cannot reach through the product.
+ *
+ * Structured JSON rather than a zip of files, and one person at a time. Both are deliberate:
+ *
+ * - **The rows are not the problem; documents are.** Five years of four punches a day is about nine
+ *   thousand rows and two to three megabytes — large for a response and bounded. A contract PDF,
+ *   three payslips a year and an identity scan has no upper bound at all, which is why the file
+ *   bytes are named in `manifest.excluded` instead of being streamed through a request handler.
+ *   Every section is capped and every cap that bites is named in `manifest.truncated`.
+ * - **There is no workspace-wide variant, and there will not be.** Five hundred people is two and a
+ *   half million rows with decrypted bank details in flight. `personId` is required and there is no
+ *   filter.
+ *
+ * `sensitive` is decrypted here, which makes this the most dangerous object the module produces —
+ * so producing it writes a `sensitive_access_log` row with `via: 'export'` before it is returned. An
+ * export is a bulk read of that record, not a smaller one.
+ */
+export declare const SubjectAccessBundle: 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>;
+export type SubjectAccessBundle = z.infer<typeof SubjectAccessBundle>;
+//# sourceMappingURL=privacy.d.ts.map