@feedmepos/mf-inventory-portal 1.7.13-dev.3 → 1.7.13-dev.6

package/dist/views/production-run/composables/use-production-run-record-output.d.ts

@@ -0,0 +1,261 @@
+import type { Ref } from 'vue';
+import type { FdoDecimal } from '@feedmepos/core/entity';
+import { type RecordProductionOutputResult } from '@/api/production-run';
+import { type ProductionRunUnitSnapshot } from '../components/production-run-unit-snapshot';
+/**
+ * The record-output dialog's session: one `operationKey`, its whole life.
+ *
+ * `complete` receipts stock for a batch. The operation key is minted once per
+ * intent and survives the request, but the QA slice makes no automatic retry
+ * or lost-response recovery claim: an ambiguous response stops and requires a
+ * reload/manual review. Defensive resume remains post-QA.
+ *
+ * Closing the dialog clears the key from memory. Persistent recovery,
+ * lost-response reconciliation and partial-write resume are explicitly
+ * post-QA; an ambiguous response stops and asks the operator to reload.
+ */
+/**
+ * Past this, a backdate stops looking like late paperwork and starts looking
+ * like a mistyped year.
+ *
+ * A THRESHOLD, not an invariant — it warns, it does not refuse. See `warnings`
+ * below for why this one is soft while the other two produced-time rules are
+ * hard, and why moving it back into `validate()` would be a regression rather
+ * than a repair.
+ */
+export declare const PRODUCED_AT_MAX_BACKDATE_DAYS = 14;
+export type RecordOutputPhase = 
+/** No dialog session — nothing minted. */
+'idle' | 'editing' | 'submitting'
+/** The request may never have arrived. Same key is safe to resend. */
+ | 'timeout'
+/** Anything else that failed but did not close the door on the key. */
+ | 'failed'
+/**
+ * The run moved under us and the request cannot be resent as-is. Distinct
+ * from `'failed'`: there is nothing to retry, only something to re-read.
+ */
+ | 'stale'
+/**
+ * A previous submission exists that this session cannot identify.
+ *
+ * Reached only from unreadable stored state. We know a write may be
+ * outstanding and we cannot reproduce it, so neither resending nor starting
+ * fresh is honest — the run has to be re-read by a human.
+ */
+ | 'blocked' | 'saved';
+export type RecordOutputErrorCode = 'overCommitted' | 'negativeOutput' | 'producedAtFuture' | 'producedAtBeforeIssue' | 'wastageAmount' | 'wastageIngredient' | 'wastageItem' | 'wastageReason' | 'wastageRemark' | 'measurementUnavailable' | 'measurementMismatch'
+/** Post-QA reserved code; no QA path persists an intent. */
+ | 'storageUnavailable';
+/**
+ * A rule the user may overrule, as distinct from one they may not.
+ *
+ * Deliberately its own union rather than a member of `RecordOutputErrorCode`
+ * with a severity beside it. The type is the statement: nothing that reaches
+ * `errors` can be acknowledged past, and nothing here refuses anything.
+ * `producedAtTooOld` sat in the error union until FM-149 was ruled, and keeping
+ * it there behind a flag would leave the next reader one boolean away from
+ * restoring a refusal that was removed on purpose.
+ */
+export type RecordOutputWarningCode = 'producedAtTooOld';
+/**
+ * Why a session is `'blocked'`. Both mean "a write may be outstanding and this
+ * session cannot resend it", and they differ only in what the user is told.
+ */
+export type RecordOutputBlockedReason = 'unreadableIntent' | 'storageUnreadable';
+/**
+ * A validation failure, as a code plus its parameters rather than a sentence.
+ *
+ * The composable is not a rendering surface and has no `t()`. Carrying the code
+ * keeps the copy in the four locale files where a translator can reach it, and
+ * keeps the spec asserting the RULE rather than an English string that a
+ * wording change would break.
+ *
+ * `field` is what the dialog scrolls to and marks — every error names one.
+ */
+export interface RecordOutputError {
+    field: string;
+    code: RecordOutputErrorCode;
+    params: Record<string, string | number>;
+}
+/**
+ * Same shape as an error, and pointedly not the same thing.
+ *
+ * Carries a code and its params for the identical reason (see above), but a
+ * warning names something the user is being ASKED about rather than told. It
+ * blocks the button only until it is acknowledged, and never populates
+ * `errors` — a validation banner headed "fix these" is the wrong sentence for
+ * a value that may well be correct.
+ */
+export interface RecordOutputWarning {
+    field: string;
+    code: RecordOutputWarningCode;
+    params: Record<string, string | number>;
+}
+export interface RecordOutputLine {
+    skuId: string;
+    name: string;
+    /** Unit abbrev from the issuance snapshot — the unit the movement was valued in. */
+    unit: string | null;
+    /**
+     * The same unit as the whole entity, which `FmUnitInput` needs to render and
+     * to police precision. The abbrev above stays for the plain-text lines that
+     * only interpolate it into a sentence.
+     */
+    unitRef: FdoInventoryUnit | null;
+    /** Frozen on the issuance, never re-read from the live catalogue. */
+    valuation: F_INVENTORY_VALUATION_METHODS | null;
+    /** Base units. */
+    committed: number;
+    /** Base units, across every batch already recorded. */
+    produced: number;
+    /** `committed - produced`, floored at 0. */
+    remaining: number;
+    /**
+     * This batch, BASE units. Every comparison on this run is in base units —
+     * committed, produced, remaining, the over-target guard — so this stays the
+     * one figure they read, whatever unit the user typed in.
+     */
+    amount: number;
+    /**
+     * What the user actually typed, verbatim, and the unit they typed it in.
+     *
+     * Sent on the wire as the pair the entity calls a unit of record: the amount
+     * is expressed IN `measurement`. Null is unresolved UI state and is never
+     * durable; the base choice carries an explicit base-UOM snapshot too. Held
+     * rather than derived back from `amount`, because converting to base and
+     * dividing out again is a rounding trip for no gain.
+     */
+    entered: FdoDecimal;
+    measurement: ProductionRunUnitSnapshot | null;
+}
+export interface RecordOutputWastageLine {
+    /** Stable list key — wastage lines have no server identity until written. */
+    key: string;
+    /** The output item being made when the loss happened. */
+    itemSkuId: string;
+    /** The ingredient that was lost. */
+    skuId: string | null;
+    /** Base units of the INGREDIENT — see `RecordOutputLine.amount`. */
+    amount: number;
+    /** The entered pair — see `RecordOutputLine.entered`. */
+    entered: FdoDecimal;
+    measurement: ProductionRunUnitSnapshot | null;
+    /** Snapshotted when the ingredient is chosen; required before submit. */
+    unitRef: FdoInventoryUnit | null;
+    reason: F_PRODUCTION_WASTAGE_REASON | null;
+    remark: string;
+}
+export interface RecordOutputOverTargetLine {
+    skuId: string;
+    name: string;
+    valuation: F_INVENTORY_VALUATION_METHODS;
+    amount: number;
+    remaining: number;
+    excess: number;
+    excessPercent: number;
+    unit: string | null;
+    /** The target was already met before this batch began. */
+    alreadyAtTarget: boolean;
+}
+export interface RecordOutputSubmitOutcome {
+    result: RecordProductionOutputResult | null;
+    /** Present when the attempt failed in a way the dialog must narrate. */
+    phase: RecordOutputPhase;
+}
+export interface RecordOutputIngredientContext {
+    unit: FdoInventoryUnit;
+    /** Frozen contributor edges for this issued ingredient. */
+    outputSkuIds: string[];
+}
+export interface UseProductionRunRecordOutput {
+    phase: Ref<RecordOutputPhase>;
+    operationKey: Ref<string | null>;
+    producedAt: Ref<string>;
+    lines: Ref<RecordOutputLine[]>;
+    /** Output SKUs deliberately left out of this batch; lines stay in memory for restore. */
+    excludedSkuIds: Ref<Set<string>>;
+    wastages: Ref<RecordOutputWastageLine[]>;
+    remark: Ref<string>;
+    errors: Ref<RecordOutputError[]>;
+    /** A hard produced-time refusal, live while the operator edits the field. */
+    producedAtError: Ref<RecordOutputError | null>;
+    /** Live, not on submit — nothing here is a refusal, so nothing waits. */
+    warnings: Ref<RecordOutputWarning[]>;
+    /** Has the user confirmed the produced time CURRENTLY in the field? */
+    producedAtAcknowledged: Ref<boolean>;
+    /** A warning stands unanswered — the button waits, the user decides. */
+    needsAcknowledgement: Ref<boolean>;
+    failureMessage: Ref<string | null>;
+    /** Always false in QA; persistent resume is post-QA. */
+    isResume: Ref<boolean>;
+    /** Why the session is `'blocked'`, so the dialog can say which one it is. */
+    blockedReason: Ref<RecordOutputBlockedReason | null>;
+    /** The freshest run this session has seen — a 409 re-reads it silently. */
+    latestRun: Ref<FdoProductionRun | null>;
+    batchNumber: Ref<number>;
+    batchTotal: Ref<number>;
+    isOpen: Ref<boolean>;
+    isSubmitting: Ref<boolean>;
+    isTerminal: Ref<boolean>;
+    canSubmit: Ref<boolean>;
+    canRetry: Ref<boolean>;
+    /** True only while the one in-memory request is in flight. */
+    isFrozen: Ref<boolean>;
+    reachesTarget: Ref<boolean>;
+    /** Any line exceeds its remaining commitment. */
+    overTarget: Ref<boolean>;
+    /** The lines over target, with the frozen valuation that decides the rule. */
+    overTargetLines: Ref<RecordOutputOverTargetLine[]>;
+    /** At least one over-target line is not weighted-average and must be refused. */
+    refusedOverTarget: Ref<boolean>;
+    earliestIssuedAt: Ref<string | null>;
+    open: (run: FdoProductionRun, ingredients?: Record<string, RecordOutputIngredientContext>) => void;
+    close: () => void;
+    addWastage: (itemSkuId?: string) => void;
+    /** Rebind asynchronously loaded issuance ingredients without reopening the operation. */
+    updateIngredientContext: (ingredients: Record<string, RecordOutputIngredientContext>) => void;
+    excludeOutput: (skuId: string) => void;
+    restoreExcludedOutputs: () => void;
+    selectWastageSku: (key: string, skuId: string | null) => void;
+    removeWastage: (key: string) => void;
+    clearErrors: () => void;
+    validate: () => RecordOutputError[];
+    submit: () => Promise<RecordOutputSubmitOutcome>;
+}
+/**
+ * `YYYY-MM-DDTHH:mm` in the browser's own zone — what `<input type="date">` and
+ * `<input type="time">` read and write. Kept local end to end and converted to
+ * an instant only at the API boundary, so a run recorded at 5:05 pm reads back
+ * as 5:05 pm rather than shifting by the offset.
+ */
+export declare function toLocalDateTimeInput(date: Date): string;
+/**
+ * Write an entered pair onto a line, and re-derive its base projection.
+ *
+ * The single place the two representations are allowed to diverge, so a caller
+ * cannot set one and forget the other — which is exactly how a base amount
+ * ends up sitting beside a non-null measurement.
+ */
+export declare function applyEntry(line: {
+    amount: number;
+    entered: FdoDecimal;
+    measurement: ProductionRunUnitSnapshot | null;
+}, entered: FdoDecimal, measurement: ProductionRunUnitSnapshot | null): void;
+/**
+ * Seed a line from a figure already in base units — the remaining commitment or
+ * zero — and record the base unit explicitly. A missing unit stays null and is
+ * refused before submission; null never means "base" for a durable quantity.
+ */
+export declare function applyBase(line: {
+    amount: number;
+    entered: FdoDecimal;
+    measurement: ProductionRunUnitSnapshot | null;
+    unitRef: FdoInventoryUnit | null;
+}, base: number, precision: number): void;
+export declare function toDecimal(value: number, precision?: number): FdoDecimal;
+/** Convert a stored decimal to the form's numeric projection. */
+export declare function fromDecimal(value: FdoDecimal): number;
+/** Compatibility for deferred recovery specs; QA never persists an intent. */
+export declare function hasPendingIntent(_dbName: string | null, _runId: string): boolean;
+export declare function useProductionRunRecordOutput(): UseProductionRunRecordOutput;

package/dist/views/production-run/composables/use-production-run-record-output.spec.d.ts

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

package/dist/views/production-run/composables/use-production-run-scroll-hint.d.ts

@@ -0,0 +1,9 @@
+import { type MaybeRefOrGetter } from 'vue';
+/** Tracks whether a bounded Production list still has content below it. */
+export declare function useProductionRunScrollHint(enabled?: MaybeRefOrGetter<boolean>): {
+    scroller: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+    canScrollFurther: import("vue").Ref<boolean, boolean>;
+    measure: () => void;
+    scheduleMeasure: () => void;
+    onScroll: () => void;
+};

package/dist/views/production-run/composables/use-production-run-table.d.ts

@@ -0,0 +1,19 @@
+import type { ColumnDef } from '@tanstack/vue-table';
+import type { WithRev } from '@/api/type';
+import type { ProductionRunLifecycleAction } from './use-production-run-actions';
+export type ProductionRunRow = WithRev<FdoProductionRun>;
+/**
+ * Column definitions for the production-run listing.
+ *
+ * Every sort is client-side because the list endpoint is unpaginated. That is
+ * correct only while the whole list is in memory: sorting one fetched page is
+ * not sorting the list, so a paginated endpoint moves sort to the server.
+ */
+export declare function useProductionRunTable(onAction: (action: ProductionRunLifecycleAction, run: ProductionRunRow) => void, 
+/** Live inventory resolves the durable sku ids into operator-facing names. */
+resolveSku?: (skuId: string) => FdoInventorySku | null | undefined, onOpen?: (run: ProductionRunRow) => void, currentSort?: () => {
+    id: string;
+    desc: boolean;
+} | undefined, onSort?: (columnId: string) => void, hrefForRun?: (run: ProductionRunRow) => string): {
+    columnDefs: ColumnDef<ProductionRunRow>[];
+};

package/dist/views/production-run/composables/use-production-run-table.spec.d.ts

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

package/dist/views/production-run/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/helpers/production-run-quantity.helper.d.ts

@@ -0,0 +1,55 @@
+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>;
+/** 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/helpers/production-run-quantity.helper.spec.d.ts

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

package/dist/views/production-run/production-run.fixture.d.ts

@@ -0,0 +1,70 @@
+import type { FCurrency, FdoDecimal, FdoDinero, FdoEmployeeRef } from '@feedmepos/core/entity';
+import { type ProductionRunUnitSnapshot } from './components/production-run-unit-snapshot';
+/**
+ * Shared builders for the production-run specs.
+ *
+ * These documents cross the JS→Dart bridge, which deserialises them strictly:
+ * a missing required field is a runtime error, not an undefined read. So the
+ * builders below produce FULLY POPULATED documents and let a spec override only
+ * what it is actually asserting on.
+ *
+ * The unit setup is deliberate: the base unit is **kg** and `GRAM` is a
+ * measurement on it, so a run recorded partly in grams and partly in kilograms
+ * exercises the conversion every quantity in this module depends on.
+ */
+export declare function dec(value: number, precision?: number): FdoDecimal;
+export declare function dinero(value: number, precision?: number, currency?: FCurrency): FdoDinero;
+export declare const ACTOR: FdoEmployeeRef;
+/** Grams, expressed against a kilogram base unit: 1 g = 0.001 kg. */
+export declare const GRAM: FdoUnitMeasurement;
+export declare const KILOGRAM: FdoInventoryUnit;
+export declare const LITRE: FdoInventoryUnit;
+/** Explicit production snapshots; generic adjustment measurements stay separate. */
+export declare const KILOGRAM_SNAPSHOT: ProductionRunUnitSnapshot;
+export declare const LITRE_SNAPSHOT: ProductionRunUnitSnapshot;
+export declare const GRAM_SNAPSHOT: ProductionRunUnitSnapshot;
+export declare function sku(id: string, unit?: FdoInventoryUnit): FdoInventorySku;
+export declare function item(skuId: string, requested: number, measurement?: FdoUnitMeasurement | ProductionRunUnitSnapshot): FdoProductionRunItem;
+export interface IssuanceLine {
+    skuId: string;
+    committed: number;
+    measurement?: FdoUnitMeasurement | ProductionRunUnitSnapshot;
+    unit?: FdoInventoryUnit;
+}
+export declare function issuance(lines: IssuanceLine[], overrides?: Partial<FdoProductionRunIssuance>): FdoProductionRunIssuance;
+export interface BatchLine {
+    skuId: string;
+    produced: number;
+    measurement?: FdoUnitMeasurement | ProductionRunUnitSnapshot;
+    unit?: FdoInventoryUnit;
+}
+export declare function batch(lines: BatchLine[], overrides?: Partial<FdoProductionRunBatch>): FdoProductionRunBatch;
+export declare function activityLog(action: F_PRODUCTION_RUN_ACTION, performedAt: string, remark?: string | null): FdoProductionRunActivityLog;
+export declare function productionRun(overrides?: Partial<FdoProductionRun>): FdoProductionRun;
+/**
+ * An issue adjustment carrying a cost pool of `poolValue`, spread over the
+ * named ingredients. `uncosted` ingredients consume stock but carry no cost
+ * balance on either side — the state that makes the pool an under-count and
+ * lights up the amber note.
+ */
+/**
+ * An issue adjustment, shaped the way `deductStock` actually writes one.
+ *
+ * The `amounts` carry `ref` — the OUTPUT sku each deduction was made for — and
+ * that line's own valuation-derived `cost`. That is not decoration: FM-127
+ * reads exactly those two fields to split the pool between outputs. A fixture
+ * with bare amounts would pass against a BOM-derived split and prove nothing
+ * about the one that ships.
+ *
+ * `perOutput` says how the pool divides. Default: everything on one output.
+ */
+export declare function issueAdjustment({ poolValue, costed, uncosted, perOutput, runId }: {
+    poolValue: number;
+    costed?: string[];
+    uncosted?: string[];
+    perOutput?: {
+        skuId: string;
+        value: number;
+    }[];
+    runId?: string;
+}): FdoInventoryAdjustment;

package/dist/views/production-run/production-run.fixture.spec.d.ts

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

package/dist/views/receive-request/composables/use-receive-request-form.d.ts

@@ -2338,7 +2338,7 @@ export declare function useReceiveRequestForm(scope: PO_SCOPE, initialDateRange?
         ref: string;
         milestones: {
             estimatedTime?: string | null | undefined;
-            type: "CANCELLED" | "DELIVERED" | "CREATED" | "PREPARING" | "IN_TRANSIT" | "FAILED_DELIVERY";
+            type: "CANCELLED" | "DELIVERED" | "PREPARING" | "CREATED" | "IN_TRANSIT" | "FAILED_DELIVERY";
             createdAt: string;
             description: string;
         }[];
@@ -2349,7 +2349,7 @@ export declare function useReceiveRequestForm(scope: PO_SCOPE, initialDateRange?
         ref: string;
         milestones: {
             estimatedTime?: string | null | undefined;
-            type: "CANCELLED" | "DELIVERED" | "CREATED" | "PREPARING" | "IN_TRANSIT" | "FAILED_DELIVERY";
+            type: "CANCELLED" | "DELIVERED" | "PREPARING" | "CREATED" | "IN_TRANSIT" | "FAILED_DELIVERY";
             createdAt: string;
             description: string;
         }[];
@@ -2360,7 +2360,7 @@ export declare function useReceiveRequestForm(scope: PO_SCOPE, initialDateRange?
         ref: string;
         milestones: {
             estimatedTime?: string | null | undefined;
-            type: "CANCELLED" | "DELIVERED" | "CREATED" | "PREPARING" | "IN_TRANSIT" | "FAILED_DELIVERY";
+            type: "CANCELLED" | "DELIVERED" | "PREPARING" | "CREATED" | "IN_TRANSIT" | "FAILED_DELIVERY";
             createdAt: string;
             description: string;
         }[];

package/dist/views/receive-request-bulk/composables/use-bulk-receive-request-form.d.ts

@@ -1509,7 +1509,7 @@ export declare function useBulkReceiveRequestForm(initialDateRange?: Partial<Dat
         ref: string;
         milestones: {
             estimatedTime?: string | null | undefined;
-            type: "CANCELLED" | "DELIVERED" | "CREATED" | "PREPARING" | "IN_TRANSIT" | "FAILED_DELIVERY";
+            type: "CANCELLED" | "DELIVERED" | "PREPARING" | "CREATED" | "IN_TRANSIT" | "FAILED_DELIVERY";
             createdAt: string;
             description: string;
         }[];
@@ -1520,7 +1520,7 @@ export declare function useBulkReceiveRequestForm(initialDateRange?: Partial<Dat
         ref: string;
         milestones: {
             estimatedTime?: string | null | undefined;
-            type: "CANCELLED" | "DELIVERED" | "CREATED" | "PREPARING" | "IN_TRANSIT" | "FAILED_DELIVERY";
+            type: "CANCELLED" | "DELIVERED" | "PREPARING" | "CREATED" | "IN_TRANSIT" | "FAILED_DELIVERY";
             createdAt: string;
             description: string;
         }[];
@@ -1531,7 +1531,7 @@ export declare function useBulkReceiveRequestForm(initialDateRange?: Partial<Dat
         ref: string;
         milestones: {
             estimatedTime?: string | null | undefined;
-            type: "CANCELLED" | "DELIVERED" | "CREATED" | "PREPARING" | "IN_TRANSIT" | "FAILED_DELIVERY";
+            type: "CANCELLED" | "DELIVERED" | "PREPARING" | "CREATED" | "IN_TRANSIT" | "FAILED_DELIVERY";
             createdAt: string;
             description: string;
         }[];

package/dist/views/stock/components/dialog/RecalculationDialog.vue.d.ts

@@ -1,24 +1,9 @@
 declare function open(): Promise<void>;
-declare function close(): void;
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
-    showButton: boolean;
-}>>, {
+declare const _default: import("vue").DefineComponent<{}, {
     open: typeof open;
-    close: typeof close;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     submitted: () => void;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
-    showButton: boolean;
-}>>> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
     onSubmitted?: (() => 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;
-    };
-};