@managemint-solutions/sdk 0.65.0 → 0.67.0

package/dist/inventory/index.d.ts

@@ -0,0 +1,7 @@
+export * from './dto';
+export { InventoryItemsResource, type InventoryItemRow } from './items';
+export { InventoryLevelsResource, type InventoryLevelRow } from './levels';
+export { InventoryLocationsResource } from './locations';
+export { InventoryMovementsResource, type CreateInventoryMovementRow } from './movements';
+export { InventoryStocktakesResource, type InventoryStocktakeRow } from './stocktakes';
+export { InventoryTransfersResource, type InventoryTransferRow, type UpdateInventoryTransferRow } from './transfers';

package/dist/inventory/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InventoryTransfersResource = exports.InventoryStocktakesResource = exports.InventoryMovementsResource = exports.InventoryLocationsResource = exports.InventoryLevelsResource = exports.InventoryItemsResource = void 0;
+__exportStar(require("./dto"), exports);
+var items_1 = require("./items");
+Object.defineProperty(exports, "InventoryItemsResource", { enumerable: true, get: function () { return items_1.InventoryItemsResource; } });
+var levels_1 = require("./levels");
+Object.defineProperty(exports, "InventoryLevelsResource", { enumerable: true, get: function () { return levels_1.InventoryLevelsResource; } });
+var locations_1 = require("./locations");
+Object.defineProperty(exports, "InventoryLocationsResource", { enumerable: true, get: function () { return locations_1.InventoryLocationsResource; } });
+var movements_1 = require("./movements");
+Object.defineProperty(exports, "InventoryMovementsResource", { enumerable: true, get: function () { return movements_1.InventoryMovementsResource; } });
+var stocktakes_1 = require("./stocktakes");
+Object.defineProperty(exports, "InventoryStocktakesResource", { enumerable: true, get: function () { return stocktakes_1.InventoryStocktakesResource; } });
+var transfers_1 = require("./transfers");
+Object.defineProperty(exports, "InventoryTransfersResource", { enumerable: true, get: function () { return transfers_1.InventoryTransfersResource; } });

package/dist/inventory/items.d.ts

@@ -0,0 +1,65 @@
+import type { MmsList } from '@managemint-solutions/entities/common';
+import type { InventoryItemEntity, InventoryItemIdentity } from '@managemint-solutions/entities/inventory';
+import type { CreateInventoryItemDto, GetInventoryItemsDto, UpdateInventoryItemDto } from '@managemint-solutions/entities/inventory/dto';
+import { EntityAuditTrail, type AuditActor, type AuditResource } from '../audit';
+import type { TypedSupabaseClient } from '../client';
+/** An item as the list page reads it, before the api folds its levels in. */
+export type InventoryItemRow = {
+    mms_id: string;
+    created_at: string;
+    name: string;
+    sku: string;
+    group_name: string;
+    cost_minor: number;
+    price_minor: number | null;
+    track_stock: boolean;
+    archived: boolean;
+};
+/** Storage bucket every item picture lives in. Public-read; writes are policy-scoped by organization. */
+export declare const ITEM_IMAGES_BUCKET = "item-images";
+/** The item as every embed names it. */
+export declare const ITEM_IDENTITY_SELECT: "mms_id, name, sku";
+/**
+ * What is kept. The stock figures (on hand, value, below reorder) are not columns here: the
+ * api reads the levels alongside and folds them, so this resource is plain CRUD on the item.
+ */
+export declare class InventoryItemsResource {
+    private readonly supabase;
+    private readonly auth;
+    private readonly table;
+    readonly audit: EntityAuditTrail;
+    constructor(supabase: TypedSupabaseClient, auth: AuditActor, audit: AuditResource);
+    /**
+     * A page of items by name. `ids` narrows the page to those items (the api resolves a
+     * `below_reorder` filter to item ids first, as it resolves `completed` for leads).
+     */
+    list(query: GetInventoryItemsDto & {
+        organization_id?: string | null;
+        ids?: string[] | null;
+    }): Promise<MmsList<InventoryItemRow>>;
+    /** The distinct groups in use, for the filter. */
+    groups(): Promise<string[]>;
+    /** The identities of the given items, for transfer lines and the count form. */
+    identities(itemIds: string[]): Promise<InventoryItemIdentity[]>;
+    /** The item without its levels; the api attaches them. */
+    getById(itemId: string): Promise<Omit<InventoryItemEntity, 'levels'>>;
+    create(input: CreateInventoryItemDto): Promise<Omit<InventoryItemEntity, 'levels'>>;
+    update(itemId: string, input: UpdateInventoryItemDto): Promise<Omit<InventoryItemEntity, 'levels'>>;
+    /** The cost per unit after a priced receipt: the price paid, set by the api. */
+    /**
+     * Stores the item's picture and puts its public URL on the row (the profile picture's shape:
+     * a new key per upload under the CDN's cache, the previous object removed once the new URL
+     * is on). The api's upload route is the one caller.
+     */
+    setImage(itemId: string, file: File): Promise<void>;
+    /** Takes the picture off the row, then out of the bucket. */
+    clearImage(itemId: string): Promise<void>;
+    setCost(itemId: string, costMinor: number): Promise<void>;
+    archive(itemId: string): Promise<Omit<InventoryItemEntity, 'levels'>>;
+    unarchive(itemId: string): Promise<Omit<InventoryItemEntity, 'levels'>>;
+    /** Hard delete; its levels cascade. The api refuses an item with movements first. */
+    remove(itemId: string): Promise<void>;
+    /** Every DTO key, the blanks as the columns' defaults. */
+    /** The row's own columns; an opening quantity on a create is the api's receipt, not a column. */
+    private columns;
+}

package/dist/inventory/items.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InventoryItemsResource = exports.ITEM_IDENTITY_SELECT = exports.ITEM_IMAGES_BUCKET = void 0;
+const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+const paths_1 = require("../supporting-files/paths");
+const paths_2 = require("../users/paths");
+const tenancy_1 = require("../tenancy");
+const transforms_1 = require("../transforms");
+/** Storage bucket every item picture lives in. Public-read; writes are policy-scoped by organization. */
+exports.ITEM_IMAGES_BUCKET = 'item-images';
+const ITEM_LIST_SELECT = `
+        mms_id,
+        created_at,
+        name,
+        sku,
+        group_name,
+        cost_minor,
+        price_minor,
+        track_stock,
+        image_url,
+        archived
+      `;
+const ITEM_DETAIL_SELECT = `
+        mms_id,
+        created_at,
+        created_by:user_profiles!created_by ${transforms_1.USER_PROFILE_EMBED},
+        updated_at,
+        last_updated_by:user_profiles!last_updated_by ${transforms_1.USER_PROFILE_EMBED},
+        name,
+        sku,
+        description,
+        group_name,
+        cost_minor,
+        price_minor,
+        track_stock,
+        image_url,
+        archived,
+        archived_at,
+        archived_by:user_profiles!archived_by ${transforms_1.USER_PROFILE_EMBED},
+        unarchived_at,
+        unarchived_by:user_profiles!unarchived_by ${transforms_1.USER_PROFILE_EMBED}
+      `;
+/** The item as every embed names it. */
+exports.ITEM_IDENTITY_SELECT = 'mms_id, name, sku';
+/**
+ * What is kept. The stock figures (on hand, value, below reorder) are not columns here: the
+ * api reads the levels alongside and folds them, so this resource is plain CRUD on the item.
+ */
+class InventoryItemsResource {
+    supabase;
+    auth;
+    table;
+    audit;
+    constructor(supabase, auth, audit) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'inventory_items',
+            entityType: enum_1.AuditTrailEntityType.INVENTORY_ITEMS,
+        });
+        this.audit = new audit_1.EntityAuditTrail(supabase, auth, enum_1.AuditTrailEntityType.INVENTORY_ITEMS);
+    }
+    /**
+     * A page of items by name. `ids` narrows the page to those items (the api resolves a
+     * `below_reorder` filter to item ids first, as it resolves `completed` for leads).
+     */
+    async list(query) {
+        const page = query.page;
+        const pageSize = query.page_size;
+        const offset = (page - 1) * pageSize;
+        const trimmedSearch = query.search?.trim();
+        let itemsQuery = (0, tenancy_1.scopeToOrganization)(this.supabase
+            .from('inventory_items')
+            .select((0, tenancy_1.withOrganization)(ITEM_LIST_SELECT, this.auth), { count: 'estimated' }), this.auth)
+            .eq('archived', query.archive)
+            .order('name')
+            .range(offset, offset + pageSize - 1);
+        if (query.organization_id) {
+            itemsQuery = itemsQuery.eq('organization_id', query.organization_id);
+        }
+        if (trimmedSearch) {
+            itemsQuery = itemsQuery.or((0, transforms_1.orIlike)(['name', 'sku', 'group_name'], trimmedSearch));
+        }
+        if (query.group_name) {
+            itemsQuery = itemsQuery.eq('group_name', query.group_name);
+        }
+        if (query.ids) {
+            itemsQuery = itemsQuery.in('mms_id', query.ids);
+        }
+        const { data, error, count } = await itemsQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (0, transforms_1.toMmsList)(data, page, pageSize, count);
+    }
+    /** The distinct groups in use, for the filter. */
+    async groups() {
+        const { data, error } = await this.supabase
+            .from('inventory_items')
+            .select('group_name')
+            .eq('organization_id', this.auth.organization_id)
+            .neq('group_name', '')
+            .order('group_name');
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return [...new Set((data ?? []).map((row) => row.group_name))];
+    }
+    /** The identities of the given items, for transfer lines and the count form. */
+    async identities(itemIds) {
+        if (itemIds.length === 0)
+            return [];
+        const { data, error } = await this.supabase
+            .from('inventory_items')
+            .select(exports.ITEM_IDENTITY_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .in('mms_id', itemIds);
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (data ?? []);
+    }
+    /** The item without its levels; the api attaches them. */
+    async getById(itemId) {
+        const { data, error } = await (0, tenancy_1.scopeToOrganization)(this.supabase.from('inventory_items').select((0, tenancy_1.withOrganization)(ITEM_DETAIL_SELECT, this.auth)), this.auth)
+            .eq('mms_id', itemId)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data;
+    }
+    async create(input) {
+        const row = await this.table.insert({
+            ...this.columns(input),
+            organization_id: this.auth.organization_id,
+            created_by: this.auth.mms_id,
+            created_at: new Date().toISOString(),
+        });
+        return this.getById(row.mms_id);
+    }
+    async update(itemId, input) {
+        await this.table.update(itemId, {
+            ...this.columns(input),
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return this.getById(itemId);
+    }
+    /** The cost per unit after a priced receipt: the price paid, set by the api. */
+    /**
+     * Stores the item's picture and puts its public URL on the row (the profile picture's shape:
+     * a new key per upload under the CDN's cache, the previous object removed once the new URL
+     * is on). The api's upload route is the one caller.
+     */
+    async setImage(itemId, file) {
+        const { name, extension } = (0, paths_1.splitFileName)((0, paths_1.sanitizeFileName)(file.name));
+        const path = `${(0, tenancy_1.requireOrganization)(this.auth)}/${itemId}/${Date.now()}-${name}${extension ? `.${extension}` : ''}`;
+        const previous = (0, paths_2.publicObjectPath)(exports.ITEM_IMAGES_BUCKET, (await this.getById(itemId)).image_url);
+        const { error } = await this.supabase.storage
+            .from(exports.ITEM_IMAGES_BUCKET)
+            .upload(path, file, { cacheControl: '3600', upsert: true });
+        if (error)
+            throw (0, errors_1.mapStorageError)(error, `Failed to upload item image: ${file.name}`);
+        await this.table.update(itemId, {
+            image_url: this.supabase.storage.from(exports.ITEM_IMAGES_BUCKET).getPublicUrl(path).data.publicUrl,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        if (previous && previous !== path) {
+            await this.supabase.storage.from(exports.ITEM_IMAGES_BUCKET).remove([previous]);
+        }
+    }
+    /** Takes the picture off the row, then out of the bucket. */
+    async clearImage(itemId) {
+        const previous = (0, paths_2.publicObjectPath)(exports.ITEM_IMAGES_BUCKET, (await this.getById(itemId)).image_url);
+        await this.table.update(itemId, {
+            image_url: null,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        if (previous)
+            await this.supabase.storage.from(exports.ITEM_IMAGES_BUCKET).remove([previous]);
+    }
+    async setCost(itemId, costMinor) {
+        await this.table.update(itemId, {
+            cost_minor: costMinor,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+    }
+    async archive(itemId) {
+        await this.table.transition(itemId, enum_1.AuditTrailAction.ARCHIVE, (0, transforms_1.archivedPatch)(this.auth.mms_id));
+        return this.getById(itemId);
+    }
+    async unarchive(itemId) {
+        await this.table.transition(itemId, enum_1.AuditTrailAction.UNARCHIVE, (0, transforms_1.unarchivedPatch)(this.auth.mms_id));
+        return this.getById(itemId);
+    }
+    /** Hard delete; its levels cascade. The api refuses an item with movements first. */
+    async remove(itemId) {
+        await this.table.remove(itemId);
+    }
+    /** Every DTO key, the blanks as the columns' defaults. */
+    /** The row's own columns; an opening quantity on a create is the api's receipt, not a column. */
+    columns(input) {
+        return {
+            name: input.name,
+            sku: input.sku ?? '',
+            description: input.description ?? '',
+            group_name: input.group_name ?? '',
+            cost_minor: input.cost_minor ?? 0,
+            price_minor: input.price_minor ?? null,
+            track_stock: input.track_stock ?? true,
+        };
+    }
+}
+exports.InventoryItemsResource = InventoryItemsResource;

package/dist/inventory/levels.d.ts

@@ -0,0 +1,52 @@
+import type { InventoryItemIdentity, InventoryLocationIdentity } from '@managemint-solutions/entities/inventory';
+import type { UpdateInventoryLevelDto } from '@managemint-solutions/entities/inventory/dto';
+import type { UserIdentity } from '@managemint-solutions/entities/users';
+import { type AuditActor, type AuditResource } from '../audit';
+import type { TypedSupabaseClient } from '../client';
+/** A level row as read: numeric columns arrive as strings and are made numbers here. */
+export type InventoryLevelRow = {
+    mms_id: string;
+    item: InventoryItemIdentity & {
+        cost_minor: number;
+        track_stock: boolean;
+        archived: boolean;
+    };
+    location: InventoryLocationIdentity;
+    on_hand: number;
+    reorder_point: number | null;
+    reorder_quantity: number | null;
+    bin: string;
+    updated_at: string | null;
+    last_updated_by: UserIdentity | null;
+};
+/**
+ * The balance of one item at one location and its reorder rule. `on_hand` moves only through
+ * `applyQuantity` - a compare-and-set the api calls right after it has written the ledger row,
+ * so a lost race is a retry, never an overwrite. The reorder rule and the bin are an ordinary
+ * audited update.
+ */
+export declare class InventoryLevelsResource {
+    private readonly supabase;
+    private readonly auth;
+    private readonly table;
+    constructor(supabase: TypedSupabaseClient, auth: AuditActor, audit: AuditResource);
+    /** The one row for the pair, or null while none exists (which reads as 0 on hand). */
+    get(itemId: string, locationId: string): Promise<InventoryLevelRow | null>;
+    /** Every level of the given items (the list page's fold), optionally at one location. */
+    listForItems(itemIds: string[], locationId?: string | null): Promise<InventoryLevelRow[]>;
+    /** Every level at one location, by item name: the count form and the location's figures. */
+    listForLocation(locationId: string): Promise<InventoryLevelRow[]>;
+    /** Every level in the organization: the hub's figures. */
+    listAll(): Promise<InventoryLevelRow[]>;
+    /** The levels with a reorder rule (the api compares on hand to it), optionally at one location. */
+    listWithReorderPoint(locationId?: string | null): Promise<InventoryLevelRow[]>;
+    /** The row for the pair, made at 0 on hand when there is none yet. */
+    ensure(itemId: string, locationId: string): Promise<InventoryLevelRow>;
+    /** The reorder rule and the bin; `on_hand` is left alone. */
+    updateSettings(itemId: string, locationId: string, input: UpdateInventoryLevelDto): Promise<InventoryLevelRow>;
+    /**
+     * Moves `on_hand` from `expected` to `next` - only while it still reads `expected`. Resolves
+     * false when it did not (another movement landed first): the caller re-reads and tries again.
+     */
+    applyQuantity(levelId: string, expected: number, next: number): Promise<boolean>;
+}

package/dist/inventory/levels.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InventoryLevelsResource = void 0;
+const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+const transforms_1 = require("../transforms");
+const items_1 = require("./items");
+const LEVEL_SELECT = `
+        mms_id,
+        item:inventory_items!item_id (${items_1.ITEM_IDENTITY_SELECT}, cost_minor, track_stock, archived),
+        location:inventory_locations!location_id (mms_id, name),
+        on_hand,
+        reorder_point,
+        reorder_quantity,
+        bin,
+        updated_at,
+        last_updated_by:user_profiles!last_updated_by ${transforms_1.USER_PROFILE_EMBED}
+      `;
+const toNumber = (value) => Number(value ?? 0);
+const toNullableNumber = (value) => (value === null || value === undefined ? null : Number(value));
+const asRow = (raw) => {
+    const row = raw;
+    return {
+        ...row,
+        on_hand: toNumber(row.on_hand),
+        reorder_point: toNullableNumber(row.reorder_point),
+        reorder_quantity: toNullableNumber(row.reorder_quantity),
+    };
+};
+/**
+ * The balance of one item at one location and its reorder rule. `on_hand` moves only through
+ * `applyQuantity` - a compare-and-set the api calls right after it has written the ledger row,
+ * so a lost race is a retry, never an overwrite. The reorder rule and the bin are an ordinary
+ * audited update.
+ */
+class InventoryLevelsResource {
+    supabase;
+    auth;
+    table;
+    constructor(supabase, auth, audit) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'inventory_levels',
+            entityType: enum_1.AuditTrailEntityType.INVENTORY_LEVELS,
+            related: { entityType: enum_1.AuditTrailEntityType.INVENTORY_ITEMS, column: 'item_id' },
+            identity: ['item_id', 'location_id'],
+        });
+    }
+    /** The one row for the pair, or null while none exists (which reads as 0 on hand). */
+    async get(itemId, locationId) {
+        const { data, error } = await this.supabase
+            .from('inventory_levels')
+            .select(LEVEL_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .eq('item_id', itemId)
+            .eq('location_id', locationId)
+            .maybeSingle();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data ? asRow(data) : null;
+    }
+    /** Every level of the given items (the list page's fold), optionally at one location. */
+    async listForItems(itemIds, locationId) {
+        if (itemIds.length === 0)
+            return [];
+        let query = this.supabase
+            .from('inventory_levels')
+            .select(LEVEL_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .in('item_id', itemIds);
+        if (locationId)
+            query = query.eq('location_id', locationId);
+        const { data, error } = await query;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (data ?? []).map(asRow);
+    }
+    /** Every level at one location, by item name: the count form and the location's figures. */
+    async listForLocation(locationId) {
+        const rows = await (0, transforms_1.allRows)((from, to) => this.supabase
+            .from('inventory_levels')
+            .select(LEVEL_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .eq('location_id', locationId)
+            .order('mms_id')
+            .range(from, to));
+        return rows.map(asRow);
+    }
+    /** Every level in the organization: the hub's figures. */
+    async listAll() {
+        const rows = await (0, transforms_1.allRows)((from, to) => this.supabase
+            .from('inventory_levels')
+            .select(LEVEL_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .order('mms_id')
+            .range(from, to));
+        return rows.map(asRow);
+    }
+    /** The levels with a reorder rule (the api compares on hand to it), optionally at one location. */
+    async listWithReorderPoint(locationId) {
+        const rows = await (0, transforms_1.allRows)((from, to) => {
+            let query = this.supabase
+                .from('inventory_levels')
+                .select(LEVEL_SELECT)
+                .eq('organization_id', this.auth.organization_id)
+                .not('reorder_point', 'is', null)
+                .order('mms_id')
+                .range(from, to);
+            if (locationId)
+                query = query.eq('location_id', locationId);
+            return query;
+        });
+        return rows.map(asRow);
+    }
+    /** The row for the pair, made at 0 on hand when there is none yet. */
+    async ensure(itemId, locationId) {
+        const existing = await this.get(itemId, locationId);
+        if (existing)
+            return existing;
+        const row = await this.table.insert({
+            item_id: itemId,
+            location_id: locationId,
+            on_hand: 0,
+            organization_id: this.auth.organization_id,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return (await this.get(row.item_id, row.location_id));
+    }
+    /** The reorder rule and the bin; `on_hand` is left alone. */
+    async updateSettings(itemId, locationId, input) {
+        const level = await this.ensure(itemId, locationId);
+        await this.table.update(level.mms_id, {
+            reorder_point: input.reorder_point,
+            reorder_quantity: input.reorder_quantity,
+            bin: input.bin ?? '',
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return (await this.get(itemId, locationId));
+    }
+    /**
+     * Moves `on_hand` from `expected` to `next` - only while it still reads `expected`. Resolves
+     * false when it did not (another movement landed first): the caller re-reads and tries again.
+     */
+    async applyQuantity(levelId, expected, next) {
+        const row = await this.table.updateWhere(levelId, (query) => query.eq('on_hand', expected), {
+            on_hand: next,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return row !== null;
+    }
+}
+exports.InventoryLevelsResource = InventoryLevelsResource;

package/dist/inventory/locations.d.ts

@@ -0,0 +1,29 @@
+import type { InventoryLocationEntity } from '@managemint-solutions/entities/inventory';
+import type { CreateInventoryLocationDto, UpdateInventoryLocationDto } from '@managemint-solutions/entities/inventory/dto';
+import { EntityAuditTrail, type AuditActor, type AuditResource } from '../audit';
+import type { TypedSupabaseClient } from '../client';
+/**
+ * Where stock is kept. A handful of rows per organization, read whole (no paging). One of them
+ * is the default: `is_default` moves between rows and is never cleared, so an organization
+ * with any location has one (the api stars the first location added; nothing is seeded).
+ */
+export declare class InventoryLocationsResource {
+    private readonly supabase;
+    private readonly auth;
+    private readonly table;
+    readonly audit: EntityAuditTrail;
+    constructor(supabase: TypedSupabaseClient, auth: AuditActor, audit: AuditResource);
+    /** The organization's locations, the default first, then by name. */
+    list(archive: boolean): Promise<InventoryLocationEntity[]>;
+    getById(locationId: string): Promise<InventoryLocationEntity>;
+    /** The default location's id; null while the organization has no location yet. */
+    defaultId(): Promise<string | null>;
+    create(input: CreateInventoryLocationDto): Promise<InventoryLocationEntity>;
+    update(locationId: string, input: UpdateInventoryLocationDto): Promise<InventoryLocationEntity>;
+    archive(locationId: string): Promise<InventoryLocationEntity>;
+    unarchive(locationId: string): Promise<InventoryLocationEntity>;
+    /** Hard delete. The levels' and transfers' `on delete restrict` keys refuse a location still in use (23503 -> 409). */
+    remove(locationId: string): Promise<void>;
+    /** Takes the star off the current default (other than `except`), so the unique index lets the next one have it. */
+    private clearDefault;
+}