@kernhq/module-inventory 0.2.0 → 0.4.0

package/dist/contract/router.d.ts

@@ -320,6 +320,1114 @@ export declare const inventoryContract: {
                 }, z.core.$strip>;
             };
         }>, Record<never, never>>;
+        /**
+         * The asset's own timeline, newest first.
+         *
+         * Paged with the same keyset discipline `assets.list` uses and the same cursor codec, because a
+         * second bookmark format is a second set of the three bugs the first one had. The bookmark is a
+         * row id; the ordering is by id, which for a uuidv7 is the clock and, unlike `created_at`, is
+         * unique — two entries written in one transaction (a create and its first custody row) share a
+         * timestamp and a page boundary between them would repeat or drop one.
+         *
+         * Reads on `inventory.asset.view`. See `permissions.ts` for why custody is not gated separately.
+         */
+        history: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            cursor: z.ZodOptional<z.ZodString>;
+            limit: z.ZodDefault<z.ZodNumber>;
+            assetId: z.ZodUUID;
+        }, z.core.$strip>, z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                id: z.ZodUUID;
+                assetId: z.ZodUUID;
+                actorId: z.ZodNullable<z.ZodUUID>;
+                action: z.ZodString;
+                changes: z.ZodArray<z.ZodObject<{
+                    field: z.ZodString;
+                    from: z.ZodUnknown;
+                    to: z.ZodUnknown;
+                }, z.core.$strip>>;
+                data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                occurredAt: z.ZodString;
+            }, 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>>;
+    };
+    /**
+     * Who is holding what.
+     *
+     * Four verbs rather than one, because "hand it to somebody" and "hand it on to somebody else" are
+     * different questions with different failure modes: assigning something already out is a mistake
+     * worth refusing, and transferring something nobody holds is a different mistake. One procedure
+     * taking `userId | null` would answer both by silently doing whatever the row happened to allow.
+     */
+    custody: {
+        /** Hand a free item to a member. Refuses if somebody already has it — that is `transfer`. */
+        assign: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            assetId: z.ZodUUID;
+            userId: z.ZodUUID;
+            note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            asset: z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                code: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodString;
+                categoryId: z.ZodNullable<z.ZodUUID>;
+                status: z.ZodEnum<{
+                    in_stock: "in_stock";
+                    assigned: "assigned";
+                    reserved: "reserved";
+                    under_repair: "under_repair";
+                    lost: "lost";
+                    retired: "retired";
+                }>;
+                custodianUserId: z.ZodNullable<z.ZodUUID>;
+                custodySince: z.ZodNullable<z.ZodString>;
+                serialNumber: z.ZodNullable<z.ZodString>;
+                location: z.ZodNullable<z.ZodString>;
+                purchasedOn: z.ZodNullable<z.ZodString>;
+                purchasedFrom: z.ZodNullable<z.ZodString>;
+                priceMinor: z.ZodNullable<z.ZodNumber>;
+                currency: z.ZodNullable<z.ZodString>;
+                warrantyUntil: z.ZodNullable<z.ZodString>;
+                photoFileId: z.ZodNullable<z.ZodUUID>;
+                custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                archivedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            period: z.ZodNullable<z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                assetId: z.ZodUUID;
+                userId: z.ZodUUID;
+                note: z.ZodNullable<z.ZodString>;
+                effectiveFrom: z.ZodString;
+                effectiveTo: z.ZodNullable<z.ZodString>;
+                createdBy: z.ZodNullable<z.ZodUUID>;
+                createdAt: 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>>;
+        /** Take it back. Closes the open period and puts the asset back in stock. */
+        return: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            assetId: z.ZodUUID;
+            note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            asset: z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                code: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodString;
+                categoryId: z.ZodNullable<z.ZodUUID>;
+                status: z.ZodEnum<{
+                    in_stock: "in_stock";
+                    assigned: "assigned";
+                    reserved: "reserved";
+                    under_repair: "under_repair";
+                    lost: "lost";
+                    retired: "retired";
+                }>;
+                custodianUserId: z.ZodNullable<z.ZodUUID>;
+                custodySince: z.ZodNullable<z.ZodString>;
+                serialNumber: z.ZodNullable<z.ZodString>;
+                location: z.ZodNullable<z.ZodString>;
+                purchasedOn: z.ZodNullable<z.ZodString>;
+                purchasedFrom: z.ZodNullable<z.ZodString>;
+                priceMinor: z.ZodNullable<z.ZodNumber>;
+                currency: z.ZodNullable<z.ZodString>;
+                warrantyUntil: z.ZodNullable<z.ZodString>;
+                photoFileId: z.ZodNullable<z.ZodUUID>;
+                custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                archivedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            period: z.ZodNullable<z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                assetId: z.ZodUUID;
+                userId: z.ZodUUID;
+                note: z.ZodNullable<z.ZodString>;
+                effectiveFrom: z.ZodString;
+                effectiveTo: z.ZodNullable<z.ZodString>;
+                createdBy: z.ZodNullable<z.ZodUUID>;
+                createdAt: 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>>;
+        /**
+         * Hand it straight on: one transaction, not a return followed by an assign.
+         *
+         * Two calls would leave the asset `in_stock` with no custodian in between — visible to anybody
+         * reading the list at that moment, and permanently visible in the timeline as a return that
+         * nobody performed.
+         */
+        transfer: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            assetId: z.ZodUUID;
+            userId: z.ZodUUID;
+            note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            asset: z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                code: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodString;
+                categoryId: z.ZodNullable<z.ZodUUID>;
+                status: z.ZodEnum<{
+                    in_stock: "in_stock";
+                    assigned: "assigned";
+                    reserved: "reserved";
+                    under_repair: "under_repair";
+                    lost: "lost";
+                    retired: "retired";
+                }>;
+                custodianUserId: z.ZodNullable<z.ZodUUID>;
+                custodySince: z.ZodNullable<z.ZodString>;
+                serialNumber: z.ZodNullable<z.ZodString>;
+                location: z.ZodNullable<z.ZodString>;
+                purchasedOn: z.ZodNullable<z.ZodString>;
+                purchasedFrom: z.ZodNullable<z.ZodString>;
+                priceMinor: z.ZodNullable<z.ZodNumber>;
+                currency: z.ZodNullable<z.ZodString>;
+                warrantyUntil: z.ZodNullable<z.ZodString>;
+                photoFileId: z.ZodNullable<z.ZodUUID>;
+                custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                archivedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            period: z.ZodNullable<z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                assetId: z.ZodUUID;
+                userId: z.ZodUUID;
+                note: z.ZodNullable<z.ZodString>;
+                effectiveFrom: z.ZodString;
+                effectiveTo: z.ZodNullable<z.ZodString>;
+                createdBy: z.ZodNullable<z.ZodUUID>;
+                createdAt: 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>>;
+        /**
+         * Every period for one asset, newest first — "who had this laptop before me".
+         *
+         * An array rather than a page, like HR's `employment.history`: the rows are bounded by how many
+         * times one item changed hands, which is tens over its life. `limit` caps it rather than
+         * paging, so the answer is never unbounded and the caller never has a cursor to keep.
+         */
+        history: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            assetId: z.ZodUUID;
+            limit: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            assetId: z.ZodUUID;
+            userId: z.ZodUUID;
+            note: z.ZodNullable<z.ZodString>;
+            effectiveFrom: z.ZodString;
+            effectiveTo: z.ZodNullable<z.ZodString>;
+            createdBy: z.ZodNullable<z.ZodUUID>;
+            createdAt: 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>>;
+        /**
+         * What one person is holding right now.
+         *
+         * Answered from `assets.custodian_user_id` — denormalised inside the same transaction that
+         * writes the period, and indexed — rather than from an open-period join, so the offboarding
+         * question ("what does Ada still have?") is one indexed read.
+         */
+        byUser: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            cursor: z.ZodOptional<z.ZodString>;
+            limit: z.ZodDefault<z.ZodNumber>;
+            userId: z.ZodUUID;
+        }, z.core.$strip>, z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                code: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodString;
+                categoryId: z.ZodNullable<z.ZodUUID>;
+                status: z.ZodEnum<{
+                    in_stock: "in_stock";
+                    assigned: "assigned";
+                    reserved: "reserved";
+                    under_repair: "under_repair";
+                    lost: "lost";
+                    retired: "retired";
+                }>;
+                custodianUserId: z.ZodNullable<z.ZodUUID>;
+                custodySince: z.ZodNullable<z.ZodString>;
+                serialNumber: z.ZodNullable<z.ZodString>;
+                location: z.ZodNullable<z.ZodString>;
+                purchasedOn: z.ZodNullable<z.ZodString>;
+                purchasedFrom: z.ZodNullable<z.ZodString>;
+                priceMinor: z.ZodNullable<z.ZodNumber>;
+                currency: z.ZodNullable<z.ZodString>;
+                warrantyUntil: z.ZodNullable<z.ZodString>;
+                photoFileId: z.ZodNullable<z.ZodUUID>;
+                custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                archivedAt: z.ZodNullable<z.ZodString>;
+            }, 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>>;
+    };
+    /**
+     * How a workspace groups what it owns.
+     *
+     * Not paged: a workspace has tens of categories, and every one of them has to be in the picker
+     * anyway. A cursor here would be a page boundary in a dropdown.
+     */
+    categories: {
+        list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            archived: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            name: z.ZodString;
+            order: z.ZodNumber;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            archivedAt: 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>>;
+        create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            name: z.ZodString;
+            order: z.ZodNumber;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            archivedAt: 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>>;
+        update: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            name: z.ZodOptional<z.ZodString>;
+            categoryId: z.ZodUUID;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            name: z.ZodString;
+            order: z.ZodNumber;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            archivedAt: 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>>;
+        /**
+         * Archive, not delete — and the same procedure restores.
+         *
+         * `assets.category_id` carries no foreign key, so a delete would leave every asset filed under
+         * it pointing at nothing: a blank column, and a timeline entry that recorded the move losing
+         * the name it recorded. Archiving is reversible and destroys nothing.
+         */
+        archive: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            categoryId: z.ZodUUID;
+            archived: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            name: z.ZodString;
+            order: z.ZodNumber;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            archivedAt: 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>>;
+        /**
+         * The whole sequence, in the order somebody put it in — the only thing that writes `order`.
+         *
+         * **The ids, not positions.** A position number is a database column with a form around it: two
+         * categories can hold the same one, nobody thinks about their filing as integers, and the screen
+         * that asked for one had to explain how ties break. A list of ids says exactly what the person
+         * did, whatever they did it with — a drag, or the move-up and move-down buttons beside it.
+         *
+         * **It must name every live category the workspace has, exactly once.** A partial list is not
+         * treated as "leave the rest alone": somebody added a category in another tab while this page
+         * was open, and the ordering in hand no longer describes the workspace. Renumbering what it does
+         * name would drop the new one somewhere nobody chose, silently — so the whole call is refused
+         * with `inventory.category.order_stale` and the page reloads and asks again. Naming an archived
+         * category is the same mistake from the other side and gets the same answer; an id from another
+         * workspace is `NOT_FOUND`, exactly as `update` and `archive` answer for one.
+         *
+         * Answers the live sequence as it now stands, so a caller needs no second read.
+         *
+         * **The bound is `MAX_LIVE_CATEGORIES`, and it is the same number `create` refuses at.** A bound
+         * on this array with nothing enforcing it elsewhere is a silent ceiling: a workspace could grow
+         * past it one category at a time and then find that the only procedure that can order them is
+         * the one it can no longer call. Held to the same number at the point of creation, the array can
+         * always name every live category a workspace is allowed to have.
+         */
+        reorder: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            categoryIds: z.ZodArray<z.ZodUUID>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            name: z.ZodString;
+            order: z.ZodNumber;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            archivedAt: 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>>;
+    };
+    /**
+     * What went away to be fixed.
+     *
+     * **Behind the `repairs` capability**, which is this module's first switchable one — so every
+     * procedure here answers **404** rather than 403 in a workspace that has it off. 403 would say
+     * "this exists and you may not have it", which is false for a company that does not record
+     * repairs, and it would contradict a panel that has already hidden the tab.
+     *
+     * Writing takes `inventory.repair.manage`; reading rides `inventory.asset.view`, for the reason
+     * custody does — "where is the projector" is the question the register exists to answer.
+     */
+    repairs: {
+        /**
+         * One asset's repairs, or the whole workspace's — the same procedure, because they are the same
+         * query with one filter and a second one would be a second thing to keep in step.
+         *
+         * `open: true` is the "what is away right now" question a dashboard card asks, and it is a
+         * filter rather than a procedure of its own for the same reason.
+         *
+         * Paged, unlike `custody.history`: one asset's repairs are bounded by how often it breaks, but
+         * a workspace's are not. Ordered newest-logged first, by row id — a uuidv7 already carries the
+         * clock and is unique, where `sent_on` is a date two repairs logged the same day share.
+         */
+        list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            assetId: z.ZodOptional<z.ZodUUID>;
+            open: z.ZodOptional<z.ZodBoolean>;
+            cursor: z.ZodOptional<z.ZodString>;
+            limit: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                assetId: z.ZodUUID;
+                summary: z.ZodString;
+                detail: z.ZodNullable<z.ZodString>;
+                vendor: z.ZodNullable<z.ZodString>;
+                costMinor: z.ZodNullable<z.ZodNumber>;
+                currency: z.ZodNullable<z.ZodString>;
+                sentOn: z.ZodString;
+                returnedOn: z.ZodNullable<z.ZodString>;
+                createdBy: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                assetCode: z.ZodString;
+                assetName: z.ZodString;
+            }, 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>>;
+        /**
+         * Send it away. Refuses when the item is already at a repairer — one open repair per asset, and
+         * `inventory_repairs_one_open_uq` is what makes that true in the database rather than merely
+         * likely in the service.
+         *
+         * `sentOn` is optional and defaults to today **on the server**: a browser clock is not a fact
+         * this module is willing to record, and the same reasoning already keeps asset tags server-side.
+         */
+        create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            summary: z.ZodString;
+            detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            vendor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            costMinor: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            currency: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            sentOn: z.ZodOptional<z.ZodISODate>;
+            assetId: z.ZodUUID;
+        }, z.core.$strip>, z.ZodObject<{
+            repair: z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                assetId: z.ZodUUID;
+                summary: z.ZodString;
+                detail: z.ZodNullable<z.ZodString>;
+                vendor: z.ZodNullable<z.ZodString>;
+                costMinor: z.ZodNullable<z.ZodNumber>;
+                currency: z.ZodNullable<z.ZodString>;
+                sentOn: z.ZodString;
+                returnedOn: z.ZodNullable<z.ZodString>;
+                createdBy: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+            }, z.core.$strip>;
+            asset: z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                code: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodString;
+                categoryId: z.ZodNullable<z.ZodUUID>;
+                status: z.ZodEnum<{
+                    in_stock: "in_stock";
+                    assigned: "assigned";
+                    reserved: "reserved";
+                    under_repair: "under_repair";
+                    lost: "lost";
+                    retired: "retired";
+                }>;
+                custodianUserId: z.ZodNullable<z.ZodUUID>;
+                custodySince: z.ZodNullable<z.ZodString>;
+                serialNumber: z.ZodNullable<z.ZodString>;
+                location: z.ZodNullable<z.ZodString>;
+                purchasedOn: z.ZodNullable<z.ZodString>;
+                purchasedFrom: z.ZodNullable<z.ZodString>;
+                priceMinor: z.ZodNullable<z.ZodNumber>;
+                currency: z.ZodNullable<z.ZodString>;
+                warrantyUntil: z.ZodNullable<z.ZodString>;
+                photoFileId: z.ZodNullable<z.ZodUUID>;
+                custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                archivedAt: z.ZodNullable<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>>;
+        /**
+         * Correct what was recorded — a vendor, a cost that arrived with the invoice a week later.
+         *
+         * Deliberately cannot set `returnedOn`: that one column decides whether the asset reads as
+         * `under_repair`, so exactly one procedure moves it and the derived status has one door rather
+         * than two.
+         */
+        update: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            summary: z.ZodOptional<z.ZodString>;
+            detail: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            vendor: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            costMinor: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
+            currency: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            sentOn: z.ZodOptional<z.ZodOptional<z.ZodISODate>>;
+            repairId: z.ZodUUID;
+        }, z.core.$strip>, z.ZodObject<{
+            repair: z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                assetId: z.ZodUUID;
+                summary: z.ZodString;
+                detail: z.ZodNullable<z.ZodString>;
+                vendor: z.ZodNullable<z.ZodString>;
+                costMinor: z.ZodNullable<z.ZodNumber>;
+                currency: z.ZodNullable<z.ZodString>;
+                sentOn: z.ZodString;
+                returnedOn: z.ZodNullable<z.ZodString>;
+                createdBy: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+            }, z.core.$strip>;
+            asset: z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                code: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodString;
+                categoryId: z.ZodNullable<z.ZodUUID>;
+                status: z.ZodEnum<{
+                    in_stock: "in_stock";
+                    assigned: "assigned";
+                    reserved: "reserved";
+                    under_repair: "under_repair";
+                    lost: "lost";
+                    retired: "retired";
+                }>;
+                custodianUserId: z.ZodNullable<z.ZodUUID>;
+                custodySince: z.ZodNullable<z.ZodString>;
+                serialNumber: z.ZodNullable<z.ZodString>;
+                location: z.ZodNullable<z.ZodString>;
+                purchasedOn: z.ZodNullable<z.ZodString>;
+                purchasedFrom: z.ZodNullable<z.ZodString>;
+                priceMinor: z.ZodNullable<z.ZodNumber>;
+                currency: z.ZodNullable<z.ZodString>;
+                warrantyUntil: z.ZodNullable<z.ZodString>;
+                photoFileId: z.ZodNullable<z.ZodUUID>;
+                custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                archivedAt: z.ZodNullable<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>>;
+        /**
+         * It came back. Closes the repair and puts the asset back to `assigned` if somebody still holds
+         * it, or `in_stock` if nobody does — never blindly to `in_stock`, which would quietly release
+         * whoever is answerable for it.
+         *
+         * Takes the cost, because that is when the invoice usually arrives.
+         */
+        complete: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            repairId: z.ZodUUID;
+            returnedOn: z.ZodOptional<z.ZodISODate>;
+            costMinor: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            currency: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            repair: z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                assetId: z.ZodUUID;
+                summary: z.ZodString;
+                detail: z.ZodNullable<z.ZodString>;
+                vendor: z.ZodNullable<z.ZodString>;
+                costMinor: z.ZodNullable<z.ZodNumber>;
+                currency: z.ZodNullable<z.ZodString>;
+                sentOn: z.ZodString;
+                returnedOn: z.ZodNullable<z.ZodString>;
+                createdBy: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+            }, z.core.$strip>;
+            asset: z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+                code: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodString;
+                categoryId: z.ZodNullable<z.ZodUUID>;
+                status: z.ZodEnum<{
+                    in_stock: "in_stock";
+                    assigned: "assigned";
+                    reserved: "reserved";
+                    under_repair: "under_repair";
+                    lost: "lost";
+                    retired: "retired";
+                }>;
+                custodianUserId: z.ZodNullable<z.ZodUUID>;
+                custodySince: z.ZodNullable<z.ZodString>;
+                serialNumber: z.ZodNullable<z.ZodString>;
+                location: z.ZodNullable<z.ZodString>;
+                purchasedOn: z.ZodNullable<z.ZodString>;
+                purchasedFrom: z.ZodNullable<z.ZodString>;
+                priceMinor: z.ZodNullable<z.ZodNumber>;
+                currency: z.ZodNullable<z.ZodString>;
+                warrantyUntil: z.ZodNullable<z.ZodString>;
+                photoFileId: z.ZodNullable<z.ZodUUID>;
+                custom: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+                archivedAt: z.ZodNullable<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>>;
+    };
+    /**
+     * Receipts, warranties, manuals — and the asset's photo, which is an `Asset` field rather than one
+     * of these.
+     *
+     * **Behind the `attachments` capability**, so these answer 404 in a workspace that has it off.
+     *
+     * **A module does not upload.** The browser sends the bytes to core's file service and hands this
+     * module the id core gave it; `add` records that this asset has that file. Nothing here streams,
+     * signs or stores anything, and `remove` detaches rather than deleting core's file — the same
+     * bytes may be attached elsewhere, and a module has no standing to destroy another module's row.
+     */
+    attachments: {
+        /**
+         * Every file on one asset, its repairs' included, each carrying its own `repairId`.
+         *
+         * Not paged and not filtered by repair: one asset's files are bounded and entirely loaded, so
+         * the panel groups them in the browser. That is the one case where filtering client-side is
+         * right, and it is the opposite of what `assets.list` may do.
+         */
+        list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            assetId: z.ZodUUID;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            assetId: z.ZodUUID;
+            repairId: z.ZodNullable<z.ZodUUID>;
+            fileId: z.ZodUUID;
+            name: z.ZodString;
+            mimeType: z.ZodNullable<z.ZodString>;
+            size: z.ZodNullable<z.ZodNumber>;
+            uploadedBy: z.ZodNullable<z.ZodUUID>;
+            createdAt: 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>>;
+        /** Attach files core already holds. `repairId` files them under one repair instead of the asset. */
+        add: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            assetId: z.ZodUUID;
+            fileIds: z.ZodArray<z.ZodUUID>;
+            repairId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            assetId: z.ZodUUID;
+            repairId: z.ZodNullable<z.ZodUUID>;
+            fileId: z.ZodUUID;
+            name: z.ZodString;
+            mimeType: z.ZodNullable<z.ZodString>;
+            size: z.ZodNullable<z.ZodNumber>;
+            uploadedBy: z.ZodNullable<z.ZodUUID>;
+            createdAt: 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>>;
+        /** Answers with the id it detached, so a client can drop exactly that row without re-reading. */
+        remove: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+            attachmentId: z.ZodUUID;
+        }, z.core.$strip>, z.ZodObject<{
+            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>>;
+    };
+    /**
+     * The register in numbers.
+     *
+     * One procedure rather than a `total` on `assets.list`, because they answer different questions:
+     * a list's total describes the filter you asked for, and this describes the workspace. The assets
+     * page needs both — "showing 50 of 214" is two numbers from two places.
+     *
+     * Not behind a capability: it counts assets, which is `core`. `outForRepair` comes back null
+     * rather than 0 where `repairs` is off — see `InventoryStats`.
+     */
+    stats: {
+        summary: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            workspaceId: z.core.$ZodBranded<z.ZodUUID, "WorkspaceId", "out">;
+        }, z.core.$strip>, z.ZodObject<{
+            total: z.ZodNumber;
+            archived: z.ZodNumber;
+            byStatus: z.ZodRecord<z.ZodEnum<{
+                in_stock: "in_stock";
+                assigned: "assigned";
+                reserved: "reserved";
+                under_repair: "under_repair";
+                lost: "lost";
+                retired: "retired";
+            }>, z.ZodNumber>;
+            outForRepair: z.ZodNullable<z.ZodNumber>;
+            unassigned: 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>>;
     };
 };
 export type InventoryContract = typeof inventoryContract;