@kernhq/module-hr 0.6.0 → 0.8.0

package/dist/contract/router.d.ts

@@ -2494,6 +2494,713 @@ export declare const hrContract: {
             };
         }>, Record<never, never>>;
     };
+    policies: {
+        list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            kind: z.ZodOptional<z.ZodEnum<{
+                overtime: "overtime";
+                accrual: "accrual";
+                carry_forward: "carry_forward";
+                rounding: "rounding";
+                working_time: "working_time";
+            }>>;
+            includeArchived: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                overtime: "overtime";
+                accrual: "accrual";
+                carry_forward: "carry_forward";
+                rounding: "rounding";
+                working_time: "working_time";
+            }>;
+            name: z.ZodString;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            effectiveFrom: z.ZodISODate;
+            effectiveTo: z.ZodNullable<z.ZodISODate>;
+            source: z.ZodEnum<{
+                custom: "custom";
+                pack: "pack";
+            }>;
+            packKey: z.ZodNullable<z.ZodString>;
+            configHash: z.ZodString;
+            archivedAt: z.ZodNullable<z.ZodISODateTime>;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            id: z.ZodUUID;
+            assignments: z.ZodArray<z.ZodObject<{
+                policyId: z.ZodUUID;
+                subjectKind: z.ZodEnum<{
+                    person: "person";
+                    office: "office";
+                    legal_entity: "legal_entity";
+                    org_unit: "org_unit";
+                    position: "position";
+                    workspace: "workspace";
+                }>;
+                subjectId: z.ZodNullable<z.ZodUUID>;
+                effectiveFrom: z.ZodISODate;
+                effectiveTo: z.ZodNullable<z.ZodISODate>;
+                priority: z.ZodNumber;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, 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>>;
+        get: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            policyId: z.ZodUUID;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                overtime: "overtime";
+                accrual: "accrual";
+                carry_forward: "carry_forward";
+                rounding: "rounding";
+                working_time: "working_time";
+            }>;
+            name: z.ZodString;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            effectiveFrom: z.ZodISODate;
+            effectiveTo: z.ZodNullable<z.ZodISODate>;
+            source: z.ZodEnum<{
+                custom: "custom";
+                pack: "pack";
+            }>;
+            packKey: z.ZodNullable<z.ZodString>;
+            configHash: z.ZodString;
+            archivedAt: z.ZodNullable<z.ZodISODateTime>;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            id: z.ZodUUID;
+            assignments: z.ZodArray<z.ZodObject<{
+                policyId: z.ZodUUID;
+                subjectKind: z.ZodEnum<{
+                    person: "person";
+                    office: "office";
+                    legal_entity: "legal_entity";
+                    org_unit: "org_unit";
+                    position: "position";
+                    workspace: "workspace";
+                }>;
+                subjectId: z.ZodNullable<z.ZodUUID>;
+                effectiveFrom: z.ZodISODate;
+                effectiveTo: z.ZodNullable<z.ZodISODate>;
+                priority: z.ZodNumber;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, 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>>;
+        create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            kind: z.ZodEnum<{
+                overtime: "overtime";
+                accrual: "accrual";
+                carry_forward: "carry_forward";
+                rounding: "rounding";
+                working_time: "working_time";
+            }>;
+            name: z.ZodString;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            effectiveFrom: z.ZodISODate;
+            effectiveTo: z.ZodOptional<z.ZodNullable<z.ZodISODate>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                overtime: "overtime";
+                accrual: "accrual";
+                carry_forward: "carry_forward";
+                rounding: "rounding";
+                working_time: "working_time";
+            }>;
+            name: z.ZodString;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            effectiveFrom: z.ZodISODate;
+            effectiveTo: z.ZodNullable<z.ZodISODate>;
+            source: z.ZodEnum<{
+                custom: "custom";
+                pack: "pack";
+            }>;
+            packKey: z.ZodNullable<z.ZodString>;
+            configHash: 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>>;
+        /**
+         * Edits a policy in place.
+         *
+         * A change that should apply from a date rather than retroactively is a **new** policy with a
+         * later `effectiveFrom`, not an edit — editing rewrites what was true in the past, and anything
+         * already derived from it becomes unexplainable.
+         */
+        update: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            policyId: z.ZodUUID;
+            name: z.ZodOptional<z.ZodString>;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            effectiveTo: z.ZodOptional<z.ZodNullable<z.ZodISODate>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                overtime: "overtime";
+                accrual: "accrual";
+                carry_forward: "carry_forward";
+                rounding: "rounding";
+                working_time: "working_time";
+            }>;
+            name: z.ZodString;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            effectiveFrom: z.ZodISODate;
+            effectiveTo: z.ZodNullable<z.ZodISODate>;
+            source: z.ZodEnum<{
+                custom: "custom";
+                pack: "pack";
+            }>;
+            packKey: z.ZodNullable<z.ZodString>;
+            configHash: 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: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            policyId: 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>>;
+        assign: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            policyId: z.ZodUUID;
+            subjectKind: z.ZodEnum<{
+                person: "person";
+                office: "office";
+                legal_entity: "legal_entity";
+                org_unit: "org_unit";
+                position: "position";
+                workspace: "workspace";
+            }>;
+            subjectId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+            effectiveFrom: z.ZodISODate;
+            effectiveTo: z.ZodOptional<z.ZodNullable<z.ZodISODate>>;
+        }, z.core.$strip>, z.ZodObject<{
+            policyId: z.ZodUUID;
+            subjectKind: z.ZodEnum<{
+                person: "person";
+                office: "office";
+                legal_entity: "legal_entity";
+                org_unit: "org_unit";
+                position: "position";
+                workspace: "workspace";
+            }>;
+            subjectId: z.ZodNullable<z.ZodUUID>;
+            effectiveFrom: z.ZodISODate;
+            effectiveTo: z.ZodNullable<z.ZodISODate>;
+            priority: z.ZodNumber;
+            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>>;
+        unassign: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            assignmentId: 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>>;
+        /**
+         * Which policy of each kind applies to this person on this date, and which rung answered.
+         *
+         * "Why does she accrue differently from her team" is the question this module gets asked, and
+         * this is what answers it without a database session.
+         */
+        resolveFor: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            personId: z.ZodUUID;
+            on: z.ZodOptional<z.ZodISODate>;
+        }, z.core.$strip>, 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>>, 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>>;
+    };
+    accrual: {
+        /**
+         * What a run would credit, per person, before it writes anything.
+         *
+         * Runs the same code the run does. A preview computed differently from the thing it previews is
+         * a preview that eventually lies.
+         */
+        preview: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            from: z.ZodISODate;
+            to: z.ZodISODate;
+            personId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strip>, z.ZodObject<{
+            periodFrom: z.ZodISODate;
+            periodTo: z.ZodISODate;
+            rows: z.ZodArray<z.ZodObject<{
+                personId: z.ZodUUID;
+                displayName: z.ZodString;
+                leaveTypeId: z.ZodUUID;
+                leaveTypeName: z.ZodString;
+                minutes: z.ZodNumber;
+                days: z.ZodNumber;
+                reason: z.ZodString;
+                alreadyAccrued: z.ZodBoolean;
+            }, z.core.$strip>>;
+            totalMinutes: z.ZodNumber;
+            skipped: z.ZodArray<z.ZodObject<{
+                personId: z.ZodUUID;
+                displayName: z.ZodString;
+                reason: 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>>;
+        /**
+         * Credits the ledger.
+         *
+         * Idempotent per person, per leave type, per period: a second run for the same window credits
+         * nothing, because an accrual job that double-credits when somebody clicks twice is worse than
+         * one that never ran.
+         */
+        run: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            from: z.ZodISODate;
+            to: z.ZodISODate;
+            personId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strip>, z.ZodObject<{
+            credited: z.ZodNumber;
+            skipped: z.ZodNumber;
+            totalMinutes: 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>>;
+    };
+    periods: {
+        list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            cursor: z.ZodOptional<z.ZodString>;
+            limit: z.ZodDefault<z.ZodNumber>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                attendance: "attendance";
+                payroll: "payroll";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    attendance: "attendance";
+                    payroll: "payroll";
+                }>;
+                legalEntityId: z.ZodNullable<z.ZodUUID>;
+                startsOn: z.ZodISODate;
+                endsOn: z.ZodISODate;
+                status: z.ZodEnum<{
+                    locked: "locked";
+                    open: "open";
+                }>;
+                lockedAt: z.ZodNullable<z.ZodISODateTime>;
+                lockedBy: z.ZodNullable<z.ZodUUID>;
+                note: z.ZodNullable<z.ZodString>;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                id: z.ZodUUID;
+            }, 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>>;
+        create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            kind: z.ZodDefault<z.ZodEnum<{
+                attendance: "attendance";
+                payroll: "payroll";
+            }>>;
+            legalEntityId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+            startsOn: z.ZodISODate;
+            endsOn: z.ZodISODate;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                attendance: "attendance";
+                payroll: "payroll";
+            }>;
+            legalEntityId: z.ZodNullable<z.ZodUUID>;
+            startsOn: z.ZodISODate;
+            endsOn: z.ZodISODate;
+            status: z.ZodEnum<{
+                locked: "locked";
+                open: "open";
+            }>;
+            lockedAt: z.ZodNullable<z.ZodISODateTime>;
+            lockedBy: z.ZodNullable<z.ZodUUID>;
+            note: z.ZodNullable<z.ZodString>;
+            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>>;
+        /** Freezes the month. Every derived day inside it stops being recomputable. */
+        lock: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            periodId: z.ZodUUID;
+            note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                attendance: "attendance";
+                payroll: "payroll";
+            }>;
+            legalEntityId: z.ZodNullable<z.ZodUUID>;
+            startsOn: z.ZodISODate;
+            endsOn: z.ZodISODate;
+            status: z.ZodEnum<{
+                locked: "locked";
+                open: "open";
+            }>;
+            lockedAt: z.ZodNullable<z.ZodISODateTime>;
+            lockedBy: z.ZodNullable<z.ZodUUID>;
+            note: z.ZodNullable<z.ZodString>;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            id: z.ZodUUID;
+            lockedDays: 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>>;
+        /**
+         * Reopens it.
+         *
+         * Dangerous on purpose: a payroll has usually been filed against a locked month, and reopening
+         * lets figures move underneath it. The response says how many days became recomputable again.
+         */
+        unlock: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            periodId: z.ZodUUID;
+            reason: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                attendance: "attendance";
+                payroll: "payroll";
+            }>;
+            legalEntityId: z.ZodNullable<z.ZodUUID>;
+            startsOn: z.ZodISODate;
+            endsOn: z.ZodISODate;
+            status: z.ZodEnum<{
+                locked: "locked";
+                open: "open";
+            }>;
+            lockedAt: z.ZodNullable<z.ZodISODateTime>;
+            lockedBy: z.ZodNullable<z.ZodUUID>;
+            note: z.ZodNullable<z.ZodString>;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            id: z.ZodUUID;
+            unlockedDays: 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>>;
+    };
     attendance: {
         /** Am I clocked in? The one call a clock widget makes. */
         state: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{