@kernhq/module-hr 0.18.1 → 0.20.0

package/dist/contract/router.d.ts

@@ -4215,6 +4215,627 @@ export declare const hrContract: {
             }>, Record<never, never>>;
         };
     };
+    /**
+     * Who works which shift on which **date**.
+     *
+     * Separate from `attendance.schedules` rather than folded into it, because the two answer
+     * different questions and only one of them has a weekly period. A schedule is a week that repeats
+     * for ever; a rotation is a cycle of any length anchored to a date, which is the only shape
+     * 4-on-4-off has. Nothing here recomputes hours — grace, rounding, overnight attribution and the
+     * auto-close sweep all stay in attendance, and a roster only decides what the day was meant to be.
+     */
+    rosters: {
+        shifts: {
+            list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                includeArchived: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                code: z.ZodNullable<z.ZodString>;
+                start: z.ZodString;
+                end: z.ZodString;
+                breakMinutes: z.ZodNumber;
+                graceInMinutes: z.ZodNumber;
+                graceOutMinutes: z.ZodNumber;
+                color: z.ZodNullable<z.ZodString>;
+                archivedAt: z.ZodNullable<z.ZodISODateTime>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, 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>>;
+            create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                name: z.ZodString;
+                code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                start: z.ZodString;
+                end: z.ZodString;
+                breakMinutes: z.ZodDefault<z.ZodNumber>;
+                graceInMinutes: z.ZodDefault<z.ZodNumber>;
+                graceOutMinutes: z.ZodDefault<z.ZodNumber>;
+                color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>, z.ZodObject<{
+                name: z.ZodString;
+                code: z.ZodNullable<z.ZodString>;
+                start: z.ZodString;
+                end: z.ZodString;
+                breakMinutes: z.ZodNumber;
+                graceInMinutes: z.ZodNumber;
+                graceOutMinutes: z.ZodNumber;
+                color: z.ZodNullable<z.ZodString>;
+                archivedAt: z.ZodNullable<z.ZodISODateTime>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, 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>>;
+            update: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                shiftId: z.ZodUUID;
+                name: z.ZodOptional<z.ZodString>;
+                code: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                start: z.ZodOptional<z.ZodString>;
+                end: z.ZodOptional<z.ZodString>;
+                breakMinutes: z.ZodOptional<z.ZodNumber>;
+                graceInMinutes: z.ZodOptional<z.ZodNumber>;
+                graceOutMinutes: z.ZodOptional<z.ZodNumber>;
+                color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>, z.ZodObject<{
+                name: z.ZodString;
+                code: z.ZodNullable<z.ZodString>;
+                start: z.ZodString;
+                end: z.ZodString;
+                breakMinutes: z.ZodNumber;
+                graceInMinutes: z.ZodNumber;
+                graceOutMinutes: z.ZodNumber;
+                color: z.ZodNullable<z.ZodString>;
+                archivedAt: z.ZodNullable<z.ZodISODateTime>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, 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>>;
+            /**
+             * Archive, never delete. Patterns and stored overrides point at a shift by id, so deleting
+             * one would empty out every day it appears on — past days included.
+             */
+            archive: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                shiftId: z.ZodUUID;
+            }, z.core.$strip>, z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+            }, 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>>;
+        };
+        patterns: {
+            list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                includeArchived: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                anchorDate: z.ZodISODate;
+                days: z.ZodArray<z.ZodArray<z.ZodUUID>>;
+                archivedAt: z.ZodNullable<z.ZodISODateTime>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, 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>>;
+            create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                name: z.ZodString;
+                anchorDate: z.ZodISODate;
+                days: z.ZodArray<z.ZodArray<z.ZodUUID>>;
+            }, z.core.$strip>, z.ZodObject<{
+                name: z.ZodString;
+                anchorDate: z.ZodISODate;
+                days: z.ZodArray<z.ZodArray<z.ZodUUID>>;
+                archivedAt: z.ZodNullable<z.ZodISODateTime>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, 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>>;
+            /**
+             * Editing a rotation moves every crew on it, on every date, at once — which is the point of a
+             * rotation being computed rather than generated, and worth saying out loud on the screen that
+             * does it.
+             */
+            update: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                patternId: z.ZodUUID;
+                name: z.ZodOptional<z.ZodString>;
+                anchorDate: z.ZodOptional<z.ZodISODate>;
+                days: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodUUID>>>;
+            }, z.core.$strip>, z.ZodObject<{
+                name: z.ZodString;
+                anchorDate: z.ZodISODate;
+                days: z.ZodArray<z.ZodArray<z.ZodUUID>>;
+                archivedAt: z.ZodNullable<z.ZodISODateTime>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, 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>>;
+            archive: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                patternId: z.ZodUUID;
+            }, z.core.$strip>, z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+            }, 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 is on which rotation, and when. `attendance.schedules` has no equivalent and should. */
+        assignments: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            personId: z.ZodOptional<z.ZodUUID>;
+            patternId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            personId: z.ZodUUID;
+            patternId: z.ZodUUID;
+            effectiveFrom: z.ZodISODate;
+            effectiveTo: z.ZodNullable<z.ZodISODate>;
+            cycleOffset: z.ZodNumber;
+            createdAt: z.ZodISODateTime;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            id: z.ZodUUID;
+        }, 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>>;
+        /**
+         * Put a crew on a rotation.
+         *
+         * Takes a list of people because a rotation is a crew's, not a person's — assigning eleven
+         * people one at a time is eleven chances to get the offset wrong. The previous assignment is
+         * closed the day before, so "which rotation was she on in March" stays answerable.
+         */
+        assign: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            patternId: z.ZodUUID;
+            personIds: z.ZodArray<z.ZodUUID>;
+            effectiveFrom: z.ZodISODate;
+            effectiveTo: z.ZodOptional<z.ZodNullable<z.ZodISODate>>;
+            cycleOffset: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            personId: z.ZodUUID;
+            patternId: z.ZodUUID;
+            effectiveFrom: z.ZodISODate;
+            effectiveTo: z.ZodNullable<z.ZodISODate>;
+            cycleOffset: z.ZodNumber;
+            createdAt: z.ZodISODateTime;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            id: z.ZodUUID;
+        }, 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>>;
+        /** Take a crew off its rotation, from the day after `effectiveTo`. Nothing is deleted. */
+        unassign: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            personIds: z.ZodArray<z.ZodUUID>;
+            effectiveTo: z.ZodISODate;
+        }, z.core.$strip>, z.ZodObject<{
+            closed: 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>>;
+        /** One person's roster over a range, rotation and overrides already resolved. */
+        days: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            personId: z.ZodOptional<z.ZodUUID>;
+            from: z.ZodISODate;
+            to: z.ZodISODate;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            personId: z.ZodUUID;
+            businessDate: z.ZodISODate;
+            shifts: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                code: z.ZodNullable<z.ZodString>;
+                start: z.ZodString;
+                end: z.ZodString;
+                breakMinutes: z.ZodNumber;
+                graceInMinutes: z.ZodNumber;
+                graceOutMinutes: z.ZodNumber;
+                color: z.ZodNullable<z.ZodString>;
+                archivedAt: z.ZodNullable<z.ZodISODateTime>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, z.core.$strip>>;
+            source: z.ZodEnum<{
+                pattern: "pattern";
+                override: "override";
+                none: "none";
+            }>;
+            note: z.ZodNullable<z.ZodString>;
+        }, 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>>;
+        /**
+         * Change one day, leaving the rotation alone.
+         *
+         * An empty `shiftIds` is "off that day" and is stored — a planned rest day and a day nothing
+         * rosters at all are different facts, and only one of them is somebody's decision.
+         */
+        set: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            personId: z.ZodUUID;
+            businessDate: z.ZodISODate;
+            shiftIds: z.ZodArray<z.ZodUUID>;
+            note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            personId: z.ZodUUID;
+            businessDate: z.ZodISODate;
+            shifts: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                code: z.ZodNullable<z.ZodString>;
+                start: z.ZodString;
+                end: z.ZodString;
+                breakMinutes: z.ZodNumber;
+                graceInMinutes: z.ZodNumber;
+                graceOutMinutes: z.ZodNumber;
+                color: z.ZodNullable<z.ZodString>;
+                archivedAt: z.ZodNullable<z.ZodISODateTime>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, z.core.$strip>>;
+            source: z.ZodEnum<{
+                pattern: "pattern";
+                override: "override";
+                none: "none";
+            }>;
+            note: z.ZodNullable<z.ZodString>;
+        }, 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>>;
+        /** Drop the exception and let the rotation speak for that day again. */
+        clear: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            personId: z.ZodUUID;
+            businessDate: z.ZodISODate;
+        }, z.core.$strip>, z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, 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 is on which shift, per day — the question a roster exists for and the one a set of weekly
+         * schedules cannot be asked without walking everybody's week.
+         */
+        coverage: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            from: z.ZodISODate;
+            to: z.ZodISODate;
+            officeId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            businessDate: z.ZodISODate;
+            slots: z.ZodArray<z.ZodObject<{
+                shift: z.ZodObject<{
+                    name: z.ZodString;
+                    code: z.ZodNullable<z.ZodString>;
+                    start: z.ZodString;
+                    end: z.ZodString;
+                    breakMinutes: z.ZodNumber;
+                    graceInMinutes: z.ZodNumber;
+                    graceOutMinutes: z.ZodNumber;
+                    color: z.ZodNullable<z.ZodString>;
+                    archivedAt: z.ZodNullable<z.ZodISODateTime>;
+                    workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                    id: z.ZodUUID;
+                }, z.core.$strip>;
+                people: z.ZodArray<z.ZodObject<{
+                    personId: z.ZodUUID;
+                    displayName: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            off: z.ZodArray<z.ZodObject<{
+                personId: z.ZodUUID;
+                displayName: z.ZodString;
+            }, 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>>;
+    };
     leave: {
         types: {
             list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
@@ -6332,6 +6953,278 @@ export declare const hrContract: {
             };
         }>, Record<never, never>>;
     };
+    /**
+     * The monthly handover to whoever runs payroll, per legal entity, frozen at v1.
+     *
+     * `exports.ts` carries the reasoning; three things about the *shape of the surface* belong here:
+     *
+     * **`legalEntityId` is required, and `periodId` is the range.** `reportInput` makes its slice
+     * optional with a `workspace` default and takes free `from`/`to` dates; neither is available here.
+     * A workspace is not an employer, and a half-month export is a question about a boundary this
+     * module already has an answer for — letting a caller draw their own reintroduces the mixed-finality
+     * problem `ReportFinality` exists to name.
+     *
+     * **`v1` is a procedure, not a parameter.** A later column set ships as `payroll.export.v2` beside
+     * this one, with this one unchanged, and both live through at least one deprecation window. A
+     * `?version=` on one mutable procedure would make the frozen path a branch inside a function three
+     * people will edit, and freezing by intention has never worked.
+     *
+     * **Both cost three keys.** `hr.payroll.export`, which ships granted to nobody, plus
+     * `hr.attendance.view_team` for the hours file and `hr.leave.view_team` for the leave file — the
+     * same second-check rule the reports follow, because an export must not answer what the row-level
+     * procedure would refuse.
+     */
+    payroll: {
+        export: {
+            /**
+             * One entity, one period, two CSVs and a manifest.
+             *
+             * Refuses an open period unless `draft` is set, refuses an entity with nobody in it, and
+             * refuses a person with no employment row covering their days here — because a row of zeros is
+             * something a payroll clerk will pay from, and an error is not.
+             */
+            v1: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                legalEntityId: z.ZodUUID;
+                periodId: z.ZodUUID;
+                draft: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                manifest: z.ZodObject<{
+                    contract: z.ZodLiteral<"kern-payroll-v1">;
+                    generatedAt: z.ZodISODateTime;
+                    kernVersion: z.ZodString;
+                    finality: z.ZodEnum<{
+                        draft: "draft";
+                        final: "final";
+                    }>;
+                    draft: z.ZodBoolean;
+                    legalEntityId: z.ZodUUID;
+                    legalEntityName: z.ZodString;
+                    country: z.ZodString;
+                    currency: z.ZodNullable<z.ZodString>;
+                    periodId: z.ZodUUID;
+                    periodStart: z.ZodISODate;
+                    periodEnd: z.ZodISODate;
+                    periodStatus: z.ZodEnum<{
+                        locked: "locked";
+                        open: "open";
+                    }>;
+                    population: z.ZodNumber;
+                    counted: z.ZodNumber;
+                    scope: z.ZodObject<{
+                        permissions: z.ZodArray<z.ZodString>;
+                        askedAt: z.ZodLiteral<"workspace">;
+                    }, z.core.$strip>;
+                    attendance: z.ZodObject<{
+                        lockedDays: z.ZodNumber;
+                        openDays: z.ZodNumber;
+                        final: z.ZodBoolean;
+                        firstOpenDay: z.ZodNullable<z.ZodISODate>;
+                        lastLockedDay: z.ZodNullable<z.ZodISODate>;
+                    }, z.core.$strip>;
+                    dayLengthMinutes: z.ZodNumber;
+                    format: z.ZodObject<{
+                        encoding: z.ZodLiteral<"utf-8">;
+                        byteOrderMark: z.ZodLiteral<true>;
+                        delimiter: z.ZodLiteral<",">;
+                        lineEnding: z.ZodLiteral<"crlf">;
+                        quoting: z.ZodLiteral<"rfc4180">;
+                        decimalSeparator: z.ZodLiteral<".">;
+                        decimalPlaces: z.ZodLiteral<2>;
+                        dateFormat: z.ZodLiteral<"iso-8601">;
+                    }, z.core.$strip>;
+                    files: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        columns: z.ZodArray<z.ZodString>;
+                        rows: z.ZodNumber;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+                files: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    contentType: z.ZodString;
+                    content: z.ZodString;
+                }, 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>>;
+            /**
+             * The same rows as JSON, with no file written and no refusal thrown.
+             *
+             * So the screen shows the totals and the reasons the export would be refused before anybody
+             * downloads anything. Deliberately not versioned: a preview is this module talking to its own
+             * screen, and nothing outside Kern parses it.
+             */
+            preview: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                legalEntityId: z.ZodUUID;
+                periodId: z.ZodUUID;
+                draft: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                manifest: z.ZodObject<{
+                    contract: z.ZodLiteral<"kern-payroll-v1">;
+                    generatedAt: z.ZodISODateTime;
+                    kernVersion: z.ZodString;
+                    finality: z.ZodEnum<{
+                        draft: "draft";
+                        final: "final";
+                    }>;
+                    draft: z.ZodBoolean;
+                    legalEntityId: z.ZodUUID;
+                    legalEntityName: z.ZodString;
+                    country: z.ZodString;
+                    currency: z.ZodNullable<z.ZodString>;
+                    periodId: z.ZodUUID;
+                    periodStart: z.ZodISODate;
+                    periodEnd: z.ZodISODate;
+                    periodStatus: z.ZodEnum<{
+                        locked: "locked";
+                        open: "open";
+                    }>;
+                    population: z.ZodNumber;
+                    counted: z.ZodNumber;
+                    scope: z.ZodObject<{
+                        permissions: z.ZodArray<z.ZodString>;
+                        askedAt: z.ZodLiteral<"workspace">;
+                    }, z.core.$strip>;
+                    attendance: z.ZodObject<{
+                        lockedDays: z.ZodNumber;
+                        openDays: z.ZodNumber;
+                        final: z.ZodBoolean;
+                        firstOpenDay: z.ZodNullable<z.ZodISODate>;
+                        lastLockedDay: z.ZodNullable<z.ZodISODate>;
+                    }, z.core.$strip>;
+                    dayLengthMinutes: z.ZodNumber;
+                    format: z.ZodObject<{
+                        encoding: z.ZodLiteral<"utf-8">;
+                        byteOrderMark: z.ZodLiteral<true>;
+                        delimiter: z.ZodLiteral<",">;
+                        lineEnding: z.ZodLiteral<"crlf">;
+                        quoting: z.ZodLiteral<"rfc4180">;
+                        decimalSeparator: z.ZodLiteral<".">;
+                        decimalPlaces: z.ZodLiteral<2>;
+                        dateFormat: z.ZodLiteral<"iso-8601">;
+                    }, z.core.$strip>;
+                    files: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        columns: z.ZodArray<z.ZodString>;
+                        rows: z.ZodNumber;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+                refusals: z.ZodArray<z.ZodObject<{
+                    code: z.ZodEnum<{
+                        "hr.period.not_locked": "hr.period.not_locked";
+                        "hr.payroll.empty": "hr.payroll.empty";
+                        "hr.payroll.no_employment": "hr.payroll.no_employment";
+                    }>;
+                    message: z.ZodString;
+                    personIds: z.ZodArray<z.ZodUUID>;
+                }, z.core.$strip>>;
+                exportable: z.ZodBoolean;
+                totals: z.ZodObject<{
+                    people: z.ZodNumber;
+                    daySheets: z.ZodNumber;
+                    scheduledMinutes: z.ZodNumber;
+                    workedMinutes: z.ZodNumber;
+                    scheduledWorkedMinutes: z.ZodNumber;
+                    breakMinutes: z.ZodNumber;
+                    overtimeMinutes: z.ZodNumber;
+                    lateMinutes: z.ZodNumber;
+                    earlyLeaveMinutes: z.ZodNumber;
+                    beyondCapMinutes: z.ZodNullable<z.ZodNumber>;
+                    cappedDays: z.ZodNumber;
+                    uncappedDays: z.ZodNumber;
+                    lockedDays: z.ZodNumber;
+                    openDays: z.ZodNumber;
+                    paidLeaveDays: z.ZodNumber;
+                    unpaidLeaveDays: z.ZodNumber;
+                }, z.core.$strip>;
+                hours: z.ZodArray<z.ZodObject<{
+                    personId: z.ZodUUID;
+                    employeeNo: z.ZodNullable<z.ZodString>;
+                    displayName: z.ZodString;
+                    employmentType: z.ZodString;
+                    fte: z.ZodNumber;
+                    contractHoursWeek: z.ZodNullable<z.ZodNumber>;
+                    costCenterCode: z.ZodNullable<z.ZodString>;
+                    positionTitle: z.ZodNullable<z.ZodString>;
+                    hiredOn: z.ZodNullable<z.ZodISODate>;
+                    terminatedOn: z.ZodNullable<z.ZodISODate>;
+                    employmentChangedInPeriod: z.ZodBoolean;
+                    daySheets: z.ZodNumber;
+                    scheduledMinutes: z.ZodNumber;
+                    workedMinutes: z.ZodNumber;
+                    scheduledWorkedMinutes: z.ZodNumber;
+                    breakMinutes: z.ZodNumber;
+                    overtimeMinutes: z.ZodNumber;
+                    lateMinutes: z.ZodNumber;
+                    earlyLeaveMinutes: z.ZodNumber;
+                    beyondCapMinutes: z.ZodNullable<z.ZodNumber>;
+                    cappedDays: z.ZodNumber;
+                    uncappedDays: z.ZodNumber;
+                    lockedDays: z.ZodNumber;
+                    openDays: z.ZodNumber;
+                    paidLeaveDays: z.ZodNumber;
+                    unpaidLeaveDays: z.ZodNumber;
+                }, z.core.$strip>>;
+                leave: z.ZodArray<z.ZodObject<{
+                    personId: z.ZodUUID;
+                    employeeNo: z.ZodNullable<z.ZodString>;
+                    leaveTypeKey: z.ZodString;
+                    leaveTypeName: z.ZodString;
+                    paid: z.ZodBoolean;
+                    unit: z.ZodEnum<{
+                        half_day: "half_day";
+                        day: "day";
+                        hour: "hour";
+                    }>;
+                    days: z.ZodNumber;
+                    requests: z.ZodNumber;
+                }, 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>>;
+        };
+    };
     privacy: {
         /**
          * Everything HR holds about one person, in one response.