@mohasinac/appkit 4.58.0 → 4.60.0

package/dist/features/inventory/components/operator-message.js

@@ -0,0 +1,41 @@
+/**
+ * A failed inventory write, as something an operator can act on.
+ *
+ * 🛑 THIS EXISTS BECAUSE `toUserMessage(undefined, undefined, { fallback })`
+ * IS THE `?? error` ANTI-PATTERN. Passing `undefined` for the code means the
+ * mapping never runs and the server's own message is always what shows — which
+ * is precisely the bug Rule #9 records: an unmapped failure printed server
+ * internals to the user, and a Node `MODULE_NOT_FOUND` with a require stack was
+ * rendered inside a modal. I wrote that call before noticing.
+ *
+ * But the inventory screens genuinely need the server's words for the 4xx
+ * cases, and that is not a contradiction. "AC60-03 is retired", "holds 2,
+ * cannot move 5" and "duplicate box code" are messages written FOR the
+ * operator, naming the box and the count, and they tell them what to do next.
+ * `GENERIC_USER_MESSAGE` in their place turns a recoverable mistake into a
+ * mystery at a station where someone is holding the physical item.
+ *
+ * So the rule is split on STATUS, which is the thing that actually
+ * distinguishes the two:
+ *
+ * · 4xx — deliberate, authored, operator-facing. Show it.
+ * · 5xx (and anything with no status) — unplanned. Route through the code map,
+ *   which terminates in a constant and never returns server text. `mapToHttpError`
+ *   also scrubs 5xx messages in production, so the server text may well already
+ *   be generic by the time it arrives — but relying on that would make this
+ *   correct only in production, and the station is also used against a local
+ *   server.
+ */
+import { toUserMessage } from "../../../errors/error-display-map.js";
+export function operatorMessage(err, t) {
+    const e = (err ?? {});
+    const status = typeof e.status === "number" ? e.status : undefined;
+    const code = typeof e.code === "string" ? e.code : undefined;
+    const message = typeof e.message === "string" ? e.message : undefined;
+    if (status !== undefined && status >= 400 && status < 500 && message) {
+        return message;
+    }
+    // No fallback argument: the point is that this branch must NOT reach the
+    // server's text. `toUserMessage` ends at `errors.codes.UNKNOWN`.
+    return toUserMessage(code, t);
+}

package/dist/features/inventory/index.d.ts

@@ -0,0 +1,13 @@
+export { STORAGE_BOXES_COLLECTION, INVENTORY_PLACEMENTS_COLLECTION, INVENTORY_MOVEMENTS_COLLECTION, BoxTypeValues, BoxStatusValues, MovementKindValues, placementId, STORAGE_BOX_FIELDS, INVENTORY_PLACEMENT_FIELDS, INVENTORY_MOVEMENT_FIELDS, } from "./schemas/firestore";
+export type { BoxType, BoxStatus, MovementKind, StorageBoxDocument, InventoryPlacementDocument, InventoryMovementDocument, } from "./schemas/firestore";
+export { StorageBoxesRepository, storageBoxesRepository, } from "./repository/storage-boxes.repository";
+export type { StorageBoxCreateInput } from "./repository/storage-boxes.repository";
+export { InventoryPlacementsRepository, inventoryPlacementsRepository, } from "./repository/inventory-placements.repository";
+export type { PlaceInput, MoveInput, PickInput, } from "./repository/inventory-placements.repository";
+export { InventoryMovementsRepository, inventoryMovementsRepository, } from "./repository/inventory-movements.repository";
+export type { InventoryMovementCreateInput } from "./repository/inventory-movements.repository";
+export { AdminStorageBoxesView, RegisterBoxForm } from "./components/AdminStorageBoxesView";
+export { AdminMoveLedgerView, MOVEMENT_KIND_TABS } from "./components/AdminMoveLedgerView";
+export { ReceiveStationView } from "./components/ReceiveStationView";
+export type { ReceiveStationViewProps, ReceivableItem, UnlinkedItem, BoxOption, } from "./components/ReceiveStationView";
+export { operatorMessage } from "./components/operator-message";

package/dist/features/inventory/index.js

@@ -0,0 +1,28 @@
+/*
+ * The inventory feature's surface.
+ *
+ * 🛑 NOT re-exported from `appkit/src/index.ts`. Every one of these reaches
+ * `firebase-admin` through `BaseRepository`, and the main barrel is reachable
+ * from the CLIENT bundle — Turbopack resolves a module's full static import
+ * graph before any tree-shaking, so one reachable repository drags
+ * `node:child_process` into a browser chunk and the production build fails on
+ * every page (Root Cause #6 / #24). Server code imports the defining module
+ * or `appkit/src/server.ts`.
+ *
+ * @tag domain:inventory
+ * @tag layer:feature
+ * @tag access:server
+ */
+export { STORAGE_BOXES_COLLECTION, INVENTORY_PLACEMENTS_COLLECTION, INVENTORY_MOVEMENTS_COLLECTION, BoxTypeValues, BoxStatusValues, MovementKindValues, placementId, STORAGE_BOX_FIELDS, INVENTORY_PLACEMENT_FIELDS, INVENTORY_MOVEMENT_FIELDS, } from "./schemas/firestore.js";
+export { StorageBoxesRepository, storageBoxesRepository, } from "./repository/storage-boxes.repository.js";
+export { InventoryPlacementsRepository, inventoryPlacementsRepository, } from "./repository/inventory-placements.repository.js";
+export { InventoryMovementsRepository, inventoryMovementsRepository, } from "./repository/inventory-movements.repository.js";
+/*
+ * The admin views. Client components, so they are safe in the main barrel —
+ * but the REPOSITORIES above are not, which is why nothing here is
+ * re-exported from `appkit/src/index.ts`.
+ */
+export { AdminStorageBoxesView, RegisterBoxForm } from "./components/AdminStorageBoxesView.js";
+export { AdminMoveLedgerView, MOVEMENT_KIND_TABS } from "./components/AdminMoveLedgerView.js";
+export { ReceiveStationView } from "./components/ReceiveStationView.js";
+export { operatorMessage } from "./components/operator-message.js";

package/dist/features/inventory/repository/inventory-movements.repository.d.ts

@@ -0,0 +1,97 @@
+import { BaseRepository, parseSieveDateValue, type SieveModel, type FirebaseSieveResult } from "../../../providers/db-firebase";
+import { type InventoryMovementDocument, type MovementKind } from "../schemas/firestore";
+export interface InventoryMovementCreateInput {
+    kind: MovementKind;
+    productId: string;
+    /** Always positive — direction is `from`/`to`, never the sign. */
+    quantity: number;
+    fromBoxId?: string;
+    toBoxId?: string;
+    occurredAt?: Date;
+    actorUid: string;
+    reason?: string;
+    shipmentId?: string;
+    productTitle?: string;
+    fromBoxCode?: string;
+    toBoxCode?: string;
+}
+export declare class InventoryMovementsRepository extends BaseRepository<InventoryMovementDocument> {
+    constructor();
+    /**
+     * Append one movement.
+     *
+     * Validates the shape before writing, because a ledger row that is
+     * internally inconsistent cannot be fixed afterwards — `update` throws.
+     */
+    append(input: InventoryMovementCreateInput): Promise<InventoryMovementDocument>;
+    /**
+     * 🛑 THE LEDGER IS APPEND-ONLY. These two throw on purpose.
+     *
+     * Not `@deprecated`, not a comment — the method bodies refuse. A ledger
+     * whose rows can be edited cannot be used as evidence, and the caller who
+     * edited one would never find out: a Firestore update succeeds silently.
+     */
+    update(): Promise<never>;
+    delete(): Promise<never>;
+    /** This product's history, newest first. */
+    listByProduct(productId: string, limit?: number): Promise<InventoryMovementDocument[]>;
+    /**
+     * Everything that entered or left one box.
+     *
+     * 🛑 TWO QUERIES MERGED, not an `or`. A movement names a box in either
+     * `fromBoxId` or `toBoxId`, and Firestore cannot `OR` across two fields
+     * without a composite that still orders by one of them — so the honest
+     * shape is two bounded reads merged and re-sorted in memory. Each is
+     * `limit`-capped, so the worst case is `2 × limit` documents.
+     */
+    listByBox(boxId: string, limit?: number): Promise<InventoryMovementDocument[]>;
+    /** Everything received from one procurement shipment. */
+    listByShipment(shipmentId: string, limit?: number): Promise<InventoryMovementDocument[]>;
+    listForAdmin(model: SieveModel): Promise<FirebaseSieveResult<InventoryMovementDocument>>;
+    /** Every Timestamp field carries `parseSieveDateValue` — Root Cause #47. */
+    static readonly SIEVE_FIELDS: {
+        id: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        kind: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        productId: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        quantity: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        fromBoxId: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        toBoxId: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        actorUid: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        shipmentId: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        occurredAt: {
+            canFilter: boolean;
+            canSort: boolean;
+            parseValue: typeof parseSieveDateValue;
+        };
+        createdAt: {
+            canFilter: boolean;
+            canSort: boolean;
+            parseValue: typeof parseSieveDateValue;
+        };
+    };
+}
+export declare const inventoryMovementsRepository: InventoryMovementsRepository;

package/dist/features/inventory/repository/inventory-movements.repository.js

@@ -0,0 +1,186 @@
+/*
+ * WHY: The ledger is the only thing that can answer "where did this go". That
+ *      is worth nothing unless it is EVIDENCE, and evidence that can be
+ *      edited is not evidence.
+ * WHAT: Append, and read back by product, by box, or by shipment.
+ *
+ * ── 🛑 APPEND-ONLY, ENFORCED IN CODE AND NOT BY CONVENTION ────────────────
+ *
+ * `update` and `delete` are overridden to THROW. A comment saying "do not
+ * edit these" is one forgetful caller away from being false, and the caller
+ * would not find out — a Firestore update succeeds silently and the row that
+ * used to prove where an item went now proves something else.
+ *
+ * `audit-inventory-ledger-append-only` blocks the other direction: a new
+ * caller reaching past this repository to the raw collection.
+ *
+ * 🛑 Immutability is also why the denormalised `productTitle` / `*BoxCode` on
+ * these rows are deliberately NEVER repaired. They are what things were
+ * CALLED at the time, which is the correct thing for a historical record to
+ * say — repairing them would rewrite history to match the present, and the
+ * whole point of the row is that it does not.
+ *
+ * Holds no PII: `actorUid` is a uid, never a name.
+ *
+ * EXPORTS: InventoryMovementsRepository, inventoryMovementsRepository,
+ *   InventoryMovementCreateInput
+ *
+ * @tag domain:inventory
+ * @tag layer:feature
+ * @tag pattern:repository
+ * @tag access:server
+ * @tag sideEffects:firestore
+ */
+import { BaseRepository, parseSieveDateValue, } from "../../../providers/db-firebase/index.js";
+import { INVENTORY_MOVEMENTS_COLLECTION, INVENTORY_MOVEMENT_FIELDS, MovementKindValues, } from "../schemas/firestore.js";
+/**
+ * Which endpoints each kind requires.
+ *
+ * 🛑 A `Record<MovementKind, …>`, so a sixth kind is a COMPILE error rather
+ * than a movement that validates against nothing. This is the shape Root
+ * Cause #58/#61 are about: a `Set<string>` or an array keyed on a union
+ * silently accepts a member nobody mapped.
+ */
+const ENDPOINTS = {
+    // Stock arrives from outside the system, so there is no origin box.
+    receive: { from: false, to: true },
+    move: { from: true, to: true },
+    // Stock leaves the system. No destination box.
+    pick: { from: true, to: false },
+    /*
+     * An adjustment is a correction to ONE box's count — a found item or a
+     * missing one — so it names the box it corrects and nothing else. Which
+     * direction it went is carried by… nothing, deliberately: `reason` is
+     * required on an adjust, and a human sentence is more use than a sign.
+     */
+    adjust: { from: false, to: true },
+    // A count that agreed. Records that the box was verified, moves nothing.
+    audit: { from: false, to: true },
+};
+export class InventoryMovementsRepository extends BaseRepository {
+    constructor() {
+        super(INVENTORY_MOVEMENTS_COLLECTION);
+    }
+    /**
+     * Append one movement.
+     *
+     * Validates the shape before writing, because a ledger row that is
+     * internally inconsistent cannot be fixed afterwards — `update` throws.
+     */
+    async append(input) {
+        if (!MovementKindValues.includes(input.kind)) {
+            throw new Error(`Unknown movement kind: ${input.kind}`);
+        }
+        if (!Number.isInteger(input.quantity) || input.quantity < 1) {
+            throw new Error(`Movement quantity must be a positive whole number, got ${input.quantity}. ` +
+                `Direction is carried by fromBoxId/toBoxId, never by the sign.`);
+        }
+        const shape = ENDPOINTS[input.kind];
+        if (shape.from && !input.fromBoxId) {
+            throw new Error(`A ${input.kind} movement needs a fromBoxId`);
+        }
+        if (!shape.from && input.fromBoxId) {
+            throw new Error(`A ${input.kind} movement must not carry a fromBoxId`);
+        }
+        if (shape.to && !input.toBoxId) {
+            throw new Error(`A ${input.kind} movement needs a toBoxId`);
+        }
+        if (!shape.to && input.toBoxId) {
+            throw new Error(`A ${input.kind} movement must not carry a toBoxId`);
+        }
+        /*
+         * 🛑 An `adjust` without a reason is a variance nobody explained, which
+         * is indistinguishable from a typo three weeks later — and the row cannot
+         * be amended to add one.
+         */
+        if (input.kind === "adjust" && !input.reason?.trim()) {
+            throw new Error("An adjust movement needs a reason");
+        }
+        return this.create({
+            ...input,
+            occurredAt: input.occurredAt ?? new Date(),
+        });
+    }
+    /**
+     * 🛑 THE LEDGER IS APPEND-ONLY. These two throw on purpose.
+     *
+     * Not `@deprecated`, not a comment — the method bodies refuse. A ledger
+     * whose rows can be edited cannot be used as evidence, and the caller who
+     * edited one would never find out: a Firestore update succeeds silently.
+     */
+    async update() {
+        throw new Error("inventoryMovements is append-only. Record a correcting `adjust` movement instead of editing history.");
+    }
+    async delete() {
+        throw new Error("inventoryMovements is append-only. A movement that did not happen is corrected with an `adjust`, not removed.");
+    }
+    /** This product's history, newest first. */
+    async listByProduct(productId, limit = 50) {
+        const snap = await this.getCollection()
+            .where(INVENTORY_MOVEMENT_FIELDS.PRODUCT_ID, "==", productId)
+            .orderBy(INVENTORY_MOVEMENT_FIELDS.OCCURRED_AT, "desc")
+            .limit(limit)
+            .get();
+        return snap.docs.map((d) => this.mapDoc(d));
+    }
+    /**
+     * Everything that entered or left one box.
+     *
+     * 🛑 TWO QUERIES MERGED, not an `or`. A movement names a box in either
+     * `fromBoxId` or `toBoxId`, and Firestore cannot `OR` across two fields
+     * without a composite that still orders by one of them — so the honest
+     * shape is two bounded reads merged and re-sorted in memory. Each is
+     * `limit`-capped, so the worst case is `2 × limit` documents.
+     */
+    async listByBox(boxId, limit = 50) {
+        const [into, outOf] = await Promise.all([
+            this.getCollection()
+                .where(INVENTORY_MOVEMENT_FIELDS.TO_BOX_ID, "==", boxId)
+                .orderBy(INVENTORY_MOVEMENT_FIELDS.OCCURRED_AT, "desc")
+                .limit(limit)
+                .get(),
+            this.getCollection()
+                .where(INVENTORY_MOVEMENT_FIELDS.FROM_BOX_ID, "==", boxId)
+                .orderBy(INVENTORY_MOVEMENT_FIELDS.OCCURRED_AT, "desc")
+                .limit(limit)
+                .get(),
+        ]);
+        const rows = [...into.docs, ...outOf.docs].map((d) => this.mapDoc(d));
+        rows.sort((a, b) => b.occurredAt.getTime() - a.occurredAt.getTime());
+        return rows.slice(0, limit);
+    }
+    /** Everything received from one procurement shipment. */
+    async listByShipment(shipmentId, limit = 200) {
+        const snap = await this.getCollection()
+            .where(INVENTORY_MOVEMENT_FIELDS.SHIPMENT_ID, "==", shipmentId)
+            .orderBy(INVENTORY_MOVEMENT_FIELDS.OCCURRED_AT, "desc")
+            .limit(limit)
+            .get();
+        return snap.docs.map((d) => this.mapDoc(d));
+    }
+    async listForAdmin(model) {
+        return this.sieveQuery(model, InventoryMovementsRepository.SIEVE_FIELDS, { defaultPageSize: 25, maxPageSize: 50 });
+    }
+}
+/** Every Timestamp field carries `parseSieveDateValue` — Root Cause #47. */
+InventoryMovementsRepository.SIEVE_FIELDS = {
+    id: { canFilter: true, canSort: false },
+    [INVENTORY_MOVEMENT_FIELDS.KIND]: { canFilter: true, canSort: false },
+    [INVENTORY_MOVEMENT_FIELDS.PRODUCT_ID]: { canFilter: true, canSort: false },
+    [INVENTORY_MOVEMENT_FIELDS.QUANTITY]: { canFilter: true, canSort: true },
+    [INVENTORY_MOVEMENT_FIELDS.FROM_BOX_ID]: { canFilter: true, canSort: false },
+    [INVENTORY_MOVEMENT_FIELDS.TO_BOX_ID]: { canFilter: true, canSort: false },
+    [INVENTORY_MOVEMENT_FIELDS.ACTOR_UID]: { canFilter: true, canSort: false },
+    [INVENTORY_MOVEMENT_FIELDS.SHIPMENT_ID]: { canFilter: true, canSort: false },
+    [INVENTORY_MOVEMENT_FIELDS.OCCURRED_AT]: {
+        canFilter: true,
+        canSort: true,
+        parseValue: parseSieveDateValue,
+    },
+    [INVENTORY_MOVEMENT_FIELDS.CREATED_AT]: {
+        canFilter: true,
+        canSort: true,
+        parseValue: parseSieveDateValue,
+    },
+};
+export const inventoryMovementsRepository = new InventoryMovementsRepository();

package/dist/features/inventory/repository/inventory-placements.repository.d.ts

@@ -0,0 +1,179 @@
+import { BaseRepository, parseSieveDateValue, type SieveModel, type FirebaseSieveResult } from "../../../providers/db-firebase";
+import { type InventoryPlacementDocument, type MovementKind } from "../schemas/firestore";
+export interface PlaceInput {
+    boxId: string;
+    boxCode: string;
+    productId: string;
+    productTitle: string;
+    productSku?: string;
+    quantity: number;
+    slot?: string;
+    actorUid: string;
+    /** Carried onto the ledger row. `receive` when it came from a shipment. */
+    kind: Extract<MovementKind, "receive" | "adjust">;
+    reason?: string;
+    shipmentId?: string;
+}
+export interface MoveInput {
+    fromBoxId: string;
+    fromBoxCode: string;
+    toBoxId: string;
+    toBoxCode: string;
+    productId: string;
+    productTitle: string;
+    productSku?: string;
+    quantity: number;
+    actorUid: string;
+}
+export interface PickInput {
+    boxId: string;
+    boxCode: string;
+    productId: string;
+    productTitle: string;
+    quantity: number;
+    actorUid: string;
+    reason?: string;
+}
+export declare class InventoryPlacementsRepository extends BaseRepository<InventoryPlacementDocument> {
+    constructor();
+    /**
+     * Is this product in this box, and how many?
+     *
+     * 🛑 One document READ, because the id is deterministic. With a generated
+     * id this would be a two-field query needing its own composite index — and
+     * a double-submit could create a second row for the same pair that silently
+     * doubles the count.
+     */
+    get(boxId: string, productId: string): Promise<InventoryPlacementDocument | null>;
+    /** What is in this box. One equality, served by the automatic index. */
+    listByBox(boxId: string, limit?: number): Promise<InventoryPlacementDocument[]>;
+    /** Where is this product. Also one equality — this is the pair that matters. */
+    listByProduct(productId: string, limit?: number): Promise<InventoryPlacementDocument[]>;
+    /**
+     * Put stock into a box — a receive, or an adjustment that found some.
+     *
+     * 🛑 Idempotent upsert via the deterministic id, and the increment happens
+     * INSIDE the transaction from the value read inside it. Reading first and
+     * writing after would lose one of two concurrent receives of the same
+     * product into the same box, which is exactly what a receive station with
+     * two people scanning does.
+     */
+    place(input: PlaceInput): Promise<void>;
+    /**
+     * Box → box.
+     *
+     * 🛑 REFUSES rather than going negative. A move of more than the source
+     * holds is a miscount, and clamping it would make the ledger assert a
+     * movement of a quantity that was not there — the one thing that makes the
+     * ledger unusable as evidence.
+     */
+    move(input: MoveInput): Promise<void>;
+    /**
+     * Take stock out of a box.
+     *
+     * 🛑 MANUAL, and never fired from checkout. An automatic decrement on
+     * payment would have the ledger assert a movement nobody performed — the
+     * stock is sold, but it is still in the box until a person walks over and
+     * picks it. A ledger recording intentions instead of actions cannot be used
+     * to find a missing item, which is its only real job.
+     *
+     * 🛑 And this does NOT touch `product.stockQuantity`. That stays
+     * authoritative and is owned by the order path; writing both is how a
+     * reserved unit gets handed back to the shelf (see the schema header).
+     */
+    pick(input: PickInput): Promise<void>;
+    /**
+     * The receive station's bulk commit — many rows, ONE transaction.
+     *
+     * 🛑 ONE TRANSACTION FOR THE WHOLE TABLE, not a loop of them. A partial
+     * receive is the worst outcome available: the operator has already
+     * physically put everything in the boxes, so a half-written commit leaves
+     * the ledger disagreeing with the shelf and no way to tell which rows
+     * landed.
+     *
+     * Firestore caps a transaction at 500 writes and each row here is two (the
+     * placement and its movement), so the caller's row limit of 50 is what
+     * keeps this inside the cap — that is why the limit exists, rather than
+     * being a UI preference.
+     *
+     * 🛑 Lives HERE rather than in the route for two reasons. API routes do not
+     * touch Firestore directly in this codebase, and more specifically
+     * `audit-inventory-ledger-append-only` allows only this file and the
+     * movements repository to write the ledger — a route doing it would be the
+     * second writer the audit exists to prevent, and I wrote exactly that before
+     * the audit caught me.
+     *
+     * 🛑 Does NOT touch `product.stockQuantity`. The shipment-link route already
+     * does, and doing both double-counts. This records WHERE stock is, never how
+     * much exists.
+     */
+    receiveBatch(input: {
+        rows: ReadonlyArray<{
+            boxId: string;
+            boxCode: string;
+            productId: string;
+            productTitle: string;
+            productSku?: string;
+            quantity: number;
+            slot?: string;
+        }>;
+        actorUid: string;
+        shipmentId?: string;
+    }): Promise<{
+        rows: number;
+        units: number;
+    }>;
+    private assertQuantity;
+    /**
+     * Append a ledger row inside the caller's transaction.
+     *
+     * 🛑 Written through the raw collection rather than
+     * `inventoryMovementsRepository.append`, because that method is not
+     * transaction-aware and a second, non-transactional write would reopen the
+     * gap this whole design closes. The VALIDATION it performs is mirrored by
+     * the typed `MovementKind` endpoints above and by the quantity assert — so
+     * the shape is still checked, by the compiler rather than at runtime.
+     *
+     * `audit-inventory-ledger-append-only` allows this one path by name.
+     */
+    private appendMovement;
+    listForAdmin(model: SieveModel): Promise<FirebaseSieveResult<InventoryPlacementDocument>>;
+    /** Every Timestamp field carries `parseSieveDateValue` — Root Cause #47. */
+    static readonly SIEVE_FIELDS: {
+        id: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        boxId: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        productId: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        quantity: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        boxCode: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        productSku: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        createdAt: {
+            canFilter: boolean;
+            canSort: boolean;
+            parseValue: typeof parseSieveDateValue;
+        };
+        updatedAt: {
+            canFilter: boolean;
+            canSort: boolean;
+            parseValue: typeof parseSieveDateValue;
+        };
+    };
+}
+export declare const inventoryPlacementsRepository: InventoryPlacementsRepository;