@feedmepos/mf-inventory-portal 1.7.15-dev.3 → 1.7.16-dev.0

package/dist/views/production-run/features/planning/use-production-run-duplicate-sources.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/views/production-run/features/planning/use-production-run-form.d.ts

@@ -0,0 +1,275 @@
+import { type Ref } from 'vue';
+import { ProductionRunOperations } from '@feedmepos/inventory-core-dart/production-run';
+import type { WithRev } from '@/api/type';
+import { type ProductionRunFailure } from '@/api/production-run-error';
+import { type ProductionRunCommitRow } from './production-run-frozen-ingredients';
+import { productionRunDisplayName } from '../../shared/model/production-run-list';
+import { type ProductionRunQuantityModel, type ProductionRunUnitSnapshot } from '../../shared/model/production-run-unit-snapshot';
+export type { ProductionRunCommitContributor, ProductionRunCommitRow } from './production-run-frozen-ingredients';
+export interface ProductionRunPlannerItem {
+    /** The controller key, which is the sku id. */
+    key: string;
+    skuId: string;
+    name: string;
+    code: string;
+    /** Base unit abbreviation — what on-hand and the ingredient tree are stated in. */
+    baseUnit: string;
+    /** The unit the quantity is currently entered in. */
+    enteredUnit: string;
+    onHand: number | null;
+    /** The requested quantity converted to the sku's base unit. */
+    baseQuantity: number;
+    sku: FdoInventorySku;
+    model: ProductionRunQuantityModel;
+    bindingCount: number;
+    bindingLines: {
+        id: string;
+        name: string;
+        amount: number;
+        unit: string;
+    }[];
+}
+export interface ProductionRunHistoricalItem {
+    key: string;
+    skuId: string;
+    name: string;
+    code: string;
+    enteredUnit: string;
+    onHand: null;
+    /** Null when the stored snapshot no longer belongs to the live base-unit family. */
+    baseUnit: string | null;
+    baseQuantity: number | null;
+    model: ProductionRunQuantityModel;
+    bindingCount: 0;
+    bindingLines: [];
+}
+/**
+ * Outputs that will draw no ingredients: a valid positive authored quantity,
+ * and nothing bound.
+ *
+ * Both halves are load-bearing. Deriving this from "contributes to no commit
+ * row" instead — which is what the planner and the Prepare dialog each did
+ * independently — conflates it with a quantity of zero, since a zero-quantity
+ * item produces no rows either. That made "No quantities set" unreachable
+ * through the planner: any selected item, unquantified, was reported as
+ * committing nothing.
+ *
+ * This classification deliberately reads the raw authored amount rather than
+ * `baseQuantity`. Base conversion is zero when a unit snapshot is missing or
+ * stale, but that is a separate validation failure: it must not hide the fact
+ * that a positively quantified output has no ingredient bindings. Submission
+ * remains gated on a valid matching snapshot below.
+ */
+export declare function unboundOutputNames(items: ProductionRunPlannerItem[]): string[];
+export interface ProductionRunShortage {
+    name: string;
+    /** How far below zero the projected balance lands. */
+    over: number;
+    unit: string;
+}
+/**
+ * One sku the seeded document listed more than once, and the single line those
+ * lines were combined into.
+ *
+ * A fact about the seed, frozen at `seedFrom`: it says what the DOCUMENT held,
+ * so later edits to the combined line must not rewrite it. Quantities are
+ * resolved to plain numbers here, each beside the unit it was stored in — the
+ * point of showing them is that they read back the way the run was written.
+ */
+export interface ProductionRunDuplicateMerge {
+    skuId: string;
+    name: string;
+    /** The stored lines, in document order, each in the unit it was saved with. */
+    sources: {
+        amount: number;
+        unit: string;
+    }[];
+    /** What they add up to, or null when the sources name different base-unit families. */
+    amount: number | null;
+    unit: string | null;
+}
+export interface ProductionRunSaveAndRequestResult {
+    run: WithRev<FdoProductionRun>;
+    /** False when the draft was saved but `request` failed — the save persists. */
+    requested: boolean;
+    failure: ProductionRunFailure | null;
+}
+export declare function useProductionRunForm(): {
+    loading: Ref<boolean, boolean>;
+    refreshingStock: Ref<boolean, boolean>;
+    loadFailure: Ref<{
+        kind: import("@/api/production-run-error").ProductionRunFailureKind;
+        message: string;
+        retrySameKey: boolean;
+        mustReload: boolean;
+        shortages: {
+            skuId: string;
+            baseUnit: {
+                name: string;
+                id: string;
+                abbrev: string;
+                conversion: {
+                    amount: number;
+                    precision: number;
+                };
+                baseUnitId: string;
+            };
+            projectedBalance: {
+                amount: number;
+                precision: number;
+            };
+        }[];
+    } | null, ProductionRunFailure | {
+        kind: import("@/api/production-run-error").ProductionRunFailureKind;
+        message: string;
+        retrySameKey: boolean;
+        mustReload: boolean;
+        shortages: {
+            skuId: string;
+            baseUnit: {
+                name: string;
+                id: string;
+                abbrev: string;
+                conversion: {
+                    amount: number;
+                    precision: number;
+                };
+                baseUnitId: string;
+            };
+            projectedBalance: {
+                amount: number;
+                precision: number;
+            };
+        }[];
+    } | null>;
+    submitting: Ref<boolean, boolean>;
+    dirty: Ref<boolean, boolean>;
+    runName: Ref<string, string>;
+    instructions: Ref<string, string>;
+    createOperationKey: Ref<string | null, string | null>;
+    items: import("vue").ComputedRef<ProductionRunPlannerItem[]>;
+    commits: import("vue").ComputedRef<ProductionRunCommitRow[]>;
+    requestedIngredientRows: (run: FdoProductionRun) => ProductionRunCommitRow[];
+    proposedIngredientRows: (run: FdoProductionRun, committed: Parameters<typeof ProductionRunOperations.proposeMovement>[0]['committed']) => ProductionRunCommitRow[];
+    shortages: import("vue").ComputedRef<ProductionRunShortage[]>;
+    candidates: import("vue").ComputedRef<{
+        sku: {
+            trackingMeasurement?: string | null | undefined;
+            isInactive?: boolean | null | undefined;
+            convert?: {
+                measurement?: string | null | undefined;
+                inventoryBindings?: {
+                    measurement?: {
+                        name: string;
+                        id: string;
+                        abbrev: string;
+                        conversion: {
+                            amount: number;
+                            precision: number;
+                        };
+                    } | null | undefined;
+                    rules?: Record<string, any> | null | undefined;
+                    alternatives?: {
+                        default?: boolean | null | undefined;
+                        trackingMeasurement?: string | null | undefined;
+                        priority?: number | null | undefined;
+                        _id: string;
+                    }[] | null | undefined;
+                    type: "RECIPE" | "SKU" | "SKU_GROUP";
+                    amount: {
+                        amount: number;
+                        precision: number;
+                    };
+                    id: string;
+                }[] | null | undefined;
+            } | null | undefined;
+            valuation?: "FIFO" | "LIFO" | "FEFO" | "WAVG" | null | undefined;
+            defaultCost?: {
+                measurement?: {
+                    name: string;
+                    id: string;
+                    abbrev: string;
+                    conversion: {
+                        amount: number;
+                        precision: number;
+                    };
+                } | null | undefined;
+                costPerUnit: {
+                    currency: "AED" | "AFN" | "ALL" | "AMD" | "ANG" | "AOA" | "ARS" | "AUD" | "AWG" | "AZN" | "BAM" | "BBD" | "BDT" | "BGN" | "BHD" | "BIF" | "BMD" | "BND" | "BOB" | "BOV" | "BRL" | "BSD" | "BTN" | "BWP" | "BYN" | "BZD" | "CAD" | "CDF" | "CHE" | "CHF" | "CHW" | "CLF" | "CLP" | "CNY" | "COP" | "COU" | "CRC" | "CUC" | "CUP" | "CVE" | "CZK" | "DJF" | "DKK" | "DOP" | "DZD" | "EGP" | "ERN" | "ETB" | "EUR" | "FJD" | "FKP" | "GBP" | "GEL" | "GHS" | "GIP" | "GMD" | "GNF" | "GTQ" | "GYD" | "HKD" | "HNL" | "HRK" | "HTG" | "HUF" | "IDR" | "ILS" | "INR" | "IQD" | "IRR" | "ISK" | "JMD" | "JOD" | "JPY" | "KES" | "KGS" | "KHR" | "KMF" | "KPW" | "KRW" | "KWD" | "KYD" | "KZT" | "LAK" | "LBP" | "LKR" | "LRD" | "LSL" | "LYD" | "MAD" | "MDL" | "MGA" | "MKD" | "MMK" | "MNT" | "MOP" | "MRU" | "MUR" | "MVR" | "MWK" | "MXN" | "MXV" | "MYR" | "MZN" | "NAD" | "NGN" | "NIO" | "NOK" | "NPR" | "NZD" | "OMR" | "PAB" | "PEN" | "PGK" | "PHP" | "PKR" | "PLN" | "PYG" | "QAR" | "RON" | "RSD" | "RUB" | "RWF" | "SAR" | "SBD" | "SCR" | "SDG" | "SEK" | "SGD" | "SHP" | "SLL" | "SOS" | "SRD" | "SSP" | "STN" | "SVC" | "SYP" | "SZL" | "THB" | "TJS" | "TMT" | "TND" | "TOP" | "TRY" | "TTD" | "TWD" | "TZS" | "UAH" | "UGX" | "USD" | "USN" | "UYI" | "UYU" | "UYW" | "UZS" | "VES" | "VND" | "VUV" | "WST" | "XAF" | "XAG" | "XAU" | "XBA" | "XBB" | "XBC" | "XBD" | "XCD" | "XDR" | "XOF" | "XPD" | "XPF" | "XPT" | "XSU" | "XTS" | "XUA" | "XXX" | "YER" | "ZAR" | "ZMW" | "ZWL";
+                    amount: number;
+                    precision: number;
+                };
+            } | null | undefined;
+            operationalGroup?: string | null | undefined;
+            thresholds?: {
+                low: number;
+                mid: number;
+            } | null | undefined;
+            customAttributes?: Record<string, any> | null | undefined;
+            unit: {
+                _id: string;
+                name: string;
+                abbrev: string;
+                precision: number;
+                measurements: {
+                    name: string;
+                    id: string;
+                    abbrev: string;
+                    conversion: {
+                        amount: number;
+                        precision: number;
+                    };
+                }[];
+            };
+            code: string;
+            _id: string;
+            name: string;
+        };
+        hasBindings: boolean;
+        onHand: number;
+    }[]>;
+    projectionFailed: Ref<boolean, boolean>;
+    duplicateMerges: Ref<{
+        skuId: string;
+        name: string;
+        sources: {
+            amount: number;
+            unit: string;
+        }[];
+        amount: number | null;
+        unit: string | null;
+    }[], ProductionRunDuplicateMerge[] | {
+        skuId: string;
+        name: string;
+        sources: {
+            amount: number;
+            unit: string;
+        }[];
+        amount: number | null;
+        unit: string | null;
+    }[]>;
+    canSubmit: import("vue").ComputedRef<boolean>;
+    canRequest: import("vue").ComputedRef<boolean>;
+    load: (options?: {
+        livePlan?: boolean;
+    }) => Promise<boolean>;
+    loadCatalogue: () => Promise<boolean>;
+    historicalItems: (run: FdoProductionRun) => ProductionRunHistoricalItem[];
+    refreshStock: () => Promise<boolean>;
+    retryProjection: () => void;
+    reset: () => void;
+    discard: () => void;
+    seedFrom: (run: FdoProductionRun) => void;
+    addItems: (skuIds: string[]) => void;
+    removeItem: (key: string) => void;
+    clearAll: () => void;
+    duplicateItems: (source: FdoProductionRun, skuIds: string[], mode: 'add' | 'replace', measurementOverrides?: Record<string, ProductionRunUnitSnapshot>) => void;
+    updateItemModel: (key: string, model: ProductionRunQuantityModel) => void;
+    updateRunName: (value: string) => void;
+    updateInstructions: (value: string) => void;
+    createDraft: () => Promise<WithRev<FdoProductionRun>>;
+    updateDraft: (id: string) => Promise<WithRev<FdoProductionRun>>;
+    createAndRequest: () => Promise<ProductionRunSaveAndRequestResult>;
+    updateAndRequest: (id: string) => Promise<ProductionRunSaveAndRequestResult>;
+    displayName: typeof productionRunDisplayName;
+};

package/dist/views/production-run/features/planning/use-production-run-form.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/views/production-run/features/prepare/PrepareRunConfirmationDialog.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/views/production-run/features/prepare/PrepareRunConfirmationDialog.vue.d.ts

@@ -0,0 +1,32 @@
+import type { ProductionRunCommitRow } from '../planning/use-production-run-form';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    shortageCount: number;
+    shortages?: ProductionRunCommitRow[] | undefined;
+    shortagesAcknowledged: boolean;
+    submitting: boolean;
+    canConfirm: boolean;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: () => void;
+    confirm: () => void;
+    "update:shortagesAcknowledged": (value: boolean) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    shortageCount: number;
+    shortages?: ProductionRunCommitRow[] | undefined;
+    shortagesAcknowledged: boolean;
+    submitting: boolean;
+    canConfirm: boolean;
+}>>> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+    "onUpdate:shortagesAcknowledged"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/views/production-run/features/prepare/PrepareRunDialog.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/views/production-run/features/prepare/PrepareRunDialog.vue.d.ts

@@ -0,0 +1,18 @@
+import type { PrepareRunDialogProps } from './PrepareRunDialogProps';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<PrepareRunDialogProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:show": (value: boolean) => void;
+    issued: (result: import("@/api/production-run").ProductionRunDocument) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<PrepareRunDialogProps>>> & Readonly<{
+    "onUpdate:show"?: ((value: boolean) => any) | undefined;
+    onIssued?: ((result: import("@/api/production-run").ProductionRunDocument) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/views/production-run/features/prepare/PrepareRunDialogProps.d.ts

@@ -0,0 +1,29 @@
+import type { PrepareProductionRunResult } from '@/api/production-run';
+import type { ProductionRunCommitRow } from '../planning/use-production-run-form';
+import type { ProductionRunQuantityModel } from '../../shared/model/production-run-unit-snapshot';
+export interface PrepareRunDialogProps {
+    show: boolean;
+    run: FdoProductionRun;
+    locationName: string | null;
+    /** Page-level utility may jump straight to the same frozen print review. */
+    initialView?: 'review' | 'print';
+}
+/** Frozen review state shared by confirmation, print and the eventual write. */
+export interface PrepareRunReview {
+    items: {
+        skuId: string;
+        name: string;
+        code: string;
+        unit: string;
+        precision: number | null;
+        model: ProductionRunQuantityModel;
+    }[];
+    ingredients: (ProductionRunCommitRow & {
+        precision: number | null;
+    })[];
+}
+export interface PrepareRunDialogEvents {
+    (event: 'update:show', value: boolean): void;
+    /** Stock moved. Carries the warnings the caller must keep on screen. */
+    (event: 'issued', result: PrepareProductionRunResult): void;
+}

package/dist/views/production-run/features/prepare/PrepareSheetDialog.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/views/production-run/features/prepare/PrepareSheetDialog.vue.d.ts

@@ -0,0 +1,26 @@
+import type { PrepareRunReview } from './PrepareRunDialogProps';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    show: boolean;
+    run: FdoProductionRun;
+    locationName: string | null;
+    review: PrepareRunReview;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:show": (value: boolean) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    show: boolean;
+    run: FdoProductionRun;
+    locationName: string | null;
+    review: PrepareRunReview;
+}>>> & Readonly<{
+    "onUpdate:show"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/views/production-run/features/prepare/ProductionRunPrepareSheet.vue.d.ts

@@ -0,0 +1,16 @@
+import type { ProductionRunPrepareSheetDocument } from './production-run-prepare-sheet';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    document: ProductionRunPrepareSheetDocument;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    document: ProductionRunPrepareSheetDocument;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/views/production-run/features/prepare/production-run-prepare-sheet-cleanup.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/views/production-run/features/prepare/production-run-prepare-sheet.d.ts

@@ -0,0 +1,18 @@
+import type { PrepareRunReview } from './PrepareRunDialogProps';
+export interface ProductionRunPrepareSheetDocument {
+    title: string;
+    runNo: FdoProductionRun['runNo'];
+    instructions: string | null;
+    locationName: string | null;
+    updatedAt: string;
+    review: PrepareRunReview;
+}
+/** Remove only malformed or expired hand-offs owned by this feature. */
+export declare function purgePrepareSheets(storage?: Storage, now?: number): void;
+/** Remove exactly one hand-off; never scan or mutate unrelated browser storage. */
+export declare function removePrepareSheet(id: string, storage?: Storage): void;
+/** Store one print hand-off without putting its operational contents in the URL. */
+export declare function storePrepareSheet(document: ProductionRunPrepareSheetDocument, storage?: Storage, now?: number): string;
+/** Consume the hand-off once. Malformed, missing and expired entries all fail closed. */
+export declare function readPrepareSheet(id: string, storage?: Storage, now?: number): ProductionRunPrepareSheetDocument;
+export declare function openPrepareSheet(document: ProductionRunPrepareSheetDocument): void;

package/dist/views/production-run/shared/helpers/production-run-navigation.d.ts

@@ -0,0 +1,6 @@
+import type { RouteLocationRaw } from 'vue-router';
+export declare function productionRunListRoute(search?: string): RouteLocationRaw;
+export declare function productionRunExitRoute(featureEnabled: boolean, search?: string): RouteLocationRaw;
+export declare function productionRunDetailRoute(id: string, search?: string): RouteLocationRaw;
+/** Keep the live shell context and replace only this feature's hand-off key. */
+export declare function productionRunPrepareSheetUrl(id: string, currentHref?: string): URL;

package/dist/views/production-run/shared/helpers/production-run-navigation.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/views/production-run/shared/helpers/production-run-precision.helper.d.ts

@@ -0,0 +1,31 @@
+/**
+ * How many decimal places a sku's quantities are meaningful to, in its BASE
+ * unit.
+ *
+ * The figure belongs to the unit — `FdoInventoryUnit.precision`, the same field
+ * the unit editor writes and every quantity input already validates against, so
+ * a display that rounds harder than the form allows is a display that hides a
+ * quantity someone was permitted to enter. Reached through
+ * `getAllowedPrecision` rather than off the field directly, because that helper
+ * is the portal's one statement of what "allowed precision" means and it is
+ * where the measurement-relative rule lives should a caller ever need it.
+ *
+ * **No measurement argument on purpose.** Everything the ingredient tree renders
+ * has already been converted to base units by the projection, so the base
+ * unit's own precision is the right increment. Passing a measurement here would
+ * answer a different question — how finely a quantity may be TYPED in grams —
+ * and silently widen every figure on the screen.
+ *
+ * Resolution is by sku rather than by unit abbrev: two units can print the same
+ * short string, and the projection rows carry ids, not units.
+ *
+ * Null when the sku is not in the catalogue — an unresolved unit, not a unit
+ * with no decimals. Callers hand that straight to `formatQuantity`, which falls
+ * back to what this module rendered at before precision was unit-derived.
+ */
+export declare function quantityPrecisionOf(sku: FdoInventorySku): number;
+/**
+ * The same rule, reached by id, for the surfaces that hold projection rows
+ * rather than skus. {@link quantityPrecisionOf} is the rule; this is the lookup.
+ */
+export declare function useQuantityPrecision(): (skuId: string) => number | null;

package/dist/views/production-run/shared/helpers/production-run-quantity.helper.d.ts

@@ -0,0 +1,57 @@
+import type { FdoDecimal } from '@feedmepos/core/entity';
+/**
+ * What the run was issued against, per production item, summed across every
+ * issuance. This — not `requestedAmount` — is the denominator of every figure
+ * after issuance: a run that committed more than it requested is not at 120%
+ * of anything.
+ */
+export declare function committedBySku(run: FdoProductionRun): Record<string, number>;
+/** Exact base-unit commitments for callers that must retain decimal precision. */
+export declare function committedBaseDecimalsBySku(run: FdoProductionRun): Record<string, FdoDecimal>;
+/** What the run has produced, per production item, summed across every batch. */
+export declare function producedBySku(run: FdoProductionRun): Record<string, number>;
+/** Total committed across production items. Zero on a run that has not issued. */
+export declare function committedTotal(run: FdoProductionRun): number;
+/** Total produced across production items. */
+export declare function producedTotal(run: FdoProductionRun): number;
+/**
+ * Committed minus produced per production item, floored at 0 — what the run
+ * still owes.
+ *
+ * Keyed on the COMMITTED items: a sku produced but never committed to (a
+ * byproduct, once those land) owes nothing and would otherwise appear as a
+ * negative remainder. Overproduction clamps to 0 for the same reason — it
+ * leaves nothing unaccounted.
+ */
+export declare function remainingBySku(run: FdoProductionRun): Record<string, number>;
+/**
+ * Output attainment at 100%: every committed item produced in full.
+ *
+ * Asked of core rather than derived from the totals above, because the totals
+ * are cross-sku SUMS and this is a per-sku question. A two-output run that made
+ * 15 of one and 5 of another against 10 each sums to 20 of 20 and is not at
+ * target; core compares item by item.
+ *
+ * It is **attainment, not yield** — the denominator is what the run committed
+ * to make, not the ingredient quantity issued. And it decides nothing: the run
+ * stays open until someone closes it. Callers use it to offer closure, to show
+ * the persistent target-reached state, and to derive a closed run's outcome.
+ */
+export declare function isAtTarget(run: FdoProductionRun): boolean;
+/**
+ * One stored amount in base units, kept as a decimal.
+ *
+ * Prefer {@link baseAmount} for anything that renders. This exists for the one
+ * case that must NOT flatten: handing a converted figure back to a core
+ * controller, where going through `number` would re-derive the precision the
+ * decimal already carries.
+ */
+export declare function baseDecimal(amount: FdoDecimal, measurement: FdoProductionUnitSnapshot): FdoDecimal;
+/** One production amount in base units. Its durable snapshot is always explicit. */
+export declare function baseAmount(amount: FdoDecimal, measurement: FdoProductionUnitSnapshot): number;
+/**
+ * Legacy inventory adjustments predate Production's required snapshot and may
+ * still encode base as null. Keep that compatibility at the adjustment read
+ * edge; durable Production quantities must use {@link baseAmount} instead.
+ */
+export declare function adjustmentBaseAmount(amount: FdoDecimal, measurement?: FdoUnitMeasurement | null): number;

package/dist/views/production-run/shared/helpers/production-run-quantity.helper.spec.d.ts

@@ -0,0 +1 @@
+export {};