@burdenoff/microfe-movethewheels 2026.930.5 → 2026.1010.2

package/dist/movethewheels/components/trip-utilization/TripReportSummary.d.ts

@@ -0,0 +1,5 @@
+import { UtilizationReportFragment } from '../../../generated/trip-utilization-operations';
+
+export declare function TripReportSummary({ report }: {
+    report: UtilizationReportFragment;
+}): import("react").JSX.Element;

package/dist/movethewheels/components/trip-utilization/TripSegmentFields.d.ts

@@ -0,0 +1,9 @@
+import { MtwTripUtilizationBasis } from '../../../generated/trip-utilization-operations';
+
+export declare function TripSegmentFields({ id, sequence, basis, onRemove, removable, }: {
+    id: string;
+    sequence: number;
+    basis: MtwTripUtilizationBasis;
+    onRemove: () => void;
+    removable: boolean;
+}): import("react").JSX.Element;

package/dist/movethewheels/hooks/useConsolidationAction.d.ts

@@ -0,0 +1,19 @@
+import { DocumentNode } from 'graphql';
+
+/** F08 retains one unresolved request across entity/context remounts; it never sends automatically. */
+export declare function useConsolidationAction(): {
+    run: (document: DocumentNode, input: Record<string, unknown>, success: string) => Promise<Record<string, unknown> | null>;
+    retryOriginal: () => Promise<void>;
+    discardAttempt: () => void;
+    refresh: () => void;
+    busy: boolean;
+    error: string | null;
+    notice: string | null;
+    revision: number;
+    uncertain: boolean;
+    recoveryInvalid: boolean;
+    canRetry: boolean;
+    originalContext: import('../utils/reuseRecovery').ReuseRecoveryScope | null;
+    originalHistoryTarget: import('../utils/consolidationHistoryTarget').OriginalConsolidationHistoryTarget | null;
+    contextKey: string;
+};

package/dist/movethewheels/hooks/useContainerCondition.d.ts

@@ -0,0 +1,21 @@
+import { DocumentNode } from 'graphql';
+import { GraphQLAttemptPolicy } from '../utils/graphqlClient';
+
+export declare function useConditionApi(attemptPolicy?: GraphQLAttemptPolicy): <T>(document: DocumentNode, variables: Record<string, unknown>) => Promise<T>;
+/** Bounded pages, cancellation of stale responses, and explicit access failures. */
+export declare function useConditionQuery<T>(document: DocumentNode, variables: Record<string, unknown> | null, revision?: number): {
+    data: T | null;
+    error: string | null;
+    loading: boolean;
+};
+/** Preserve a request's idempotency key through transport retries until success. */
+export declare function useConditionAction(): {
+    run: <T>(document: DocumentNode, input: Record<string, unknown>, success: string) => Promise<T | null>;
+    busy: boolean;
+    error: string | null;
+    notice: string | null;
+    revision: number;
+    resetFeedback: () => void;
+    hasPendingAttempt: boolean;
+    discardAttempt: () => void;
+};

package/dist/movethewheels/hooks/useContainerLifecycle.d.ts

@@ -0,0 +1,40 @@
+import { ContainerEquipmentFieldsFragment, ContainerCycleFieldsFragment, ContainerEventFieldsFragment, RegisterMtwContainerInput, OpenMtwContainerCycleInput, RecordMtwContainerEventInput } from '../../generated/container-operations';
+
+export declare const EQUIPMENT_TYPES: readonly ["DRY_20", "DRY_40", "HIGH_CUBE_40", "REEFER_20", "REEFER_40", "OPEN_TOP", "FLAT_RACK", "TANK", "OTHER"];
+export declare const CONTAINER_EVENT_TYPES: readonly ["GATE_OUT", "LOADED", "DISCHARGED", "AVAILABLE_FOR_PICKUP", "GATE_IN", "DELIVERED", "EMPTY_READY", "RETURN_REQUESTED", "EMPTY_RETURNED", "RETURN_ACCEPTED", "POSITION_UPDATE"];
+export type EquipmentType = (typeof EQUIPMENT_TYPES)[number];
+export type ContainerEventType = (typeof CONTAINER_EVENT_TYPES)[number];
+export type ContainerEventKind = 'ACTUAL' | 'PLANNED' | 'ESTIMATED';
+export type ContainerRecord = ContainerEquipmentFieldsFragment;
+export type ContainerCycle = ContainerCycleFieldsFragment;
+export type ContainerEvent = ContainerEventFieldsFragment;
+/** Source-labelled physical equipment; cargo shipment completion does not close a cycle. */
+export declare function useContainerLifecycle(): {
+    containers: ContainerEquipmentFieldsFragment[];
+    cycles: ContainerCycleFieldsFragment[];
+    events: ContainerEventFieldsFragment[];
+    containerId: string;
+    cycleId: string;
+    loading: boolean;
+    cyclesLoading: boolean;
+    eventsLoading: boolean;
+    error: string | null;
+    cycleError: string | null;
+    eventError: string | null;
+    page: number;
+    setPage: import('react').Dispatch<import('react').SetStateAction<number>>;
+    cyclePage: number;
+    setCyclePage: import('react').Dispatch<import('react').SetStateAction<number>>;
+    eventPage: number;
+    setEventPage: import('react').Dispatch<import('react').SetStateAction<number>>;
+    hasMore: boolean;
+    hasMoreCycles: boolean;
+    hasMoreEvents: boolean;
+    selectContainer: (id: string) => void;
+    selectCycle: (id: string) => void;
+    refresh: () => void;
+    register: (input: Omit<RegisterMtwContainerInput, "idempotencyKey">) => Promise<void>;
+    openCycle: (input: Omit<OpenMtwContainerCycleInput, "idempotencyKey">) => Promise<void>;
+    recordEvent: (input: Omit<RecordMtwContainerEventInput, "idempotencyKey">) => Promise<void>;
+    closeCycle: (cycle: ContainerCycle) => Promise<void>;
+};

package/dist/movethewheels/hooks/useEmptyReuseAction.d.ts

@@ -0,0 +1,14 @@
+import { DocumentNode } from 'graphql';
+
+/** An uncertain retry keeps its original body and key, even after a read refresh. */
+export declare function useEmptyReuseAction(): {
+    run: <T>(document: DocumentNode, input: Record<string, unknown>, success: string) => Promise<T | null>;
+    retryOriginal: () => Promise<void>;
+    busy: boolean;
+    error: string | null;
+    notice: string | null;
+    uncertain: boolean;
+    revision: number;
+    refresh: () => void;
+    discardAttempt: () => void;
+};

package/dist/movethewheels/hooks/useFreightRecoveryAction.d.ts

@@ -0,0 +1,23 @@
+import { DocumentNode } from 'graphql';
+import { SaveFreightCostsMutation } from '../../generated/freight-cost-operations';
+
+/** F06 retains one unresolved request across entity/context remounts; it never sends automatically. */
+export declare function useFreightRecoveryAction(): {
+    run: (document: DocumentNode, input: Record<string, unknown>, success: string) => Promise<SaveFreightCostsMutation | null>;
+    retryOriginal: () => Promise<void>;
+    discardAttempt: () => void;
+    refresh: () => void;
+    busy: boolean;
+    error: string | null;
+    notice: string | null;
+    revision: number;
+    uncertain: boolean;
+    recoveryInvalid: boolean;
+    canRetry: boolean;
+    originalContext: import('../utils/reuseRecovery').ReuseRecoveryScope | null;
+    originalHistoryTarget: {
+        shipmentId: string;
+        estimateReference: string;
+    } | null;
+    contextKey: string;
+};

package/dist/movethewheels/hooks/useProcedureAction.d.ts

@@ -0,0 +1,18 @@
+import { DocumentNode } from 'graphql';
+
+/** F05 retains one unresolved request across entity/context remounts; it never sends automatically. */
+export declare function useProcedureAction(): {
+    run: (document: DocumentNode, input: Record<string, unknown>, success: string) => Promise<Record<string, unknown> | null>;
+    retryOriginal: () => Promise<void>;
+    discardAttempt: () => void;
+    refresh: () => void;
+    busy: boolean;
+    error: string | null;
+    notice: string | null;
+    revision: number;
+    uncertain: boolean;
+    recoveryInvalid: boolean;
+    canRetry: boolean;
+    originalContext: import('../utils/reuseRecovery').ReuseRecoveryScope | null;
+    contextKey: string;
+};

package/dist/movethewheels/hooks/useProcedureSelection.d.ts

@@ -0,0 +1,51 @@
+import { ProcedureContainersQuery, ProcedureCyclesQuery, ProcedureProposalsQuery } from '../../generated/logistics-procedure-operations';
+
+export declare function useProcedureSelection(revision: number): {
+    containerId: string;
+    cycleId: string;
+    proposalId: string;
+    containerOffset: number;
+    cycleOffset: number;
+    proposalOffset: number;
+    containers: {
+        data: ProcedureContainersQuery | null;
+        error: string | null;
+        loading: boolean;
+    };
+    cycles: {
+        data: ProcedureCyclesQuery | null;
+        error: string | null;
+        loading: boolean;
+    };
+    proposals: {
+        data: ProcedureProposalsQuery | null;
+        error: string | null;
+        loading: boolean;
+    };
+    cycle: {
+        __typename?: "MtwContainerCycle";
+        id: string;
+        version: number;
+        status: import('../../generated/logistics-procedure-operations').MtwContainerCycleStatus;
+        bookingReference?: string | null;
+        openedAt: string;
+    } | null;
+    proposal: {
+        __typename?: "MtwReuseProposal";
+        id: string;
+        proposalReference: string;
+        revision: number;
+        exportBookingReference: string;
+        exporterReference: string;
+        handoffLocationReference: string;
+        handoffFrom: string;
+        handoffUntil: string;
+        instructionId: string;
+    } | null;
+    selectContainer: (value: string) => void;
+    selectCycle: (value: string) => void;
+    selectProposal: import('react').Dispatch<import('react').SetStateAction<string>>;
+    pageContainers: (offset: number) => void;
+    pageCycles: (offset: number) => void;
+    pageProposals: (offset: number) => void;
+};

package/dist/movethewheels/hooks/useReuseRecoveryAction.d.ts

@@ -0,0 +1,18 @@
+import { DocumentNode } from 'graphql';
+
+/** F02 retains one unresolved request across entity/context remounts; it never sends automatically. */
+export declare function useReuseRecoveryAction(): {
+    run: <T>(document: DocumentNode, input: Record<string, unknown>, success: string) => Promise<T | null>;
+    retryOriginal: () => Promise<void>;
+    discardAttempt: () => void;
+    refresh: () => void;
+    busy: boolean;
+    error: string | null;
+    notice: string | null;
+    revision: number;
+    uncertain: boolean;
+    recoveryInvalid: boolean;
+    canRetry: boolean;
+    originalContext: import('../utils/reuseRecovery').ReuseRecoveryScope | null;
+    contextKey: string;
+};

package/dist/movethewheels/pages/ConsolidationPage.d.ts

@@ -0,0 +1 @@
+export default function ConsolidationPage(): import("react").JSX.Element;

package/dist/movethewheels/pages/ContainerConditionPage.d.ts

@@ -0,0 +1 @@
+export default function ContainerConditionPage(): import("react").JSX.Element;

package/dist/movethewheels/pages/ContainersPage.d.ts

@@ -0,0 +1,2 @@
+/** Remount on identity/workspace changes so previous workspace records never flash. */
+export default function ContainersPage(): import("react").JSX.Element;

package/dist/movethewheels/pages/EmptyReusePage.d.ts

@@ -0,0 +1 @@
+export default function EmptyReusePage(): import("react").JSX.Element;

package/dist/movethewheels/pages/FreeTimePage.d.ts

@@ -0,0 +1 @@
+export default function FreeTimePage(): import("react").JSX.Element;

package/dist/movethewheels/pages/FreightEstimatePage.d.ts

@@ -0,0 +1 @@
+export default function FreightEstimatePage(): import("react").JSX.Element;

package/dist/movethewheels/pages/LogisticsProceduresPage.d.ts

@@ -0,0 +1 @@
+export default function LogisticsProceduresPage(): import("react").JSX.Element;

package/dist/movethewheels/pages/PendingPickPage.d.ts

@@ -0,0 +1 @@
+export default function PendingPickPage(): import("react").JSX.Element;

package/dist/movethewheels/pages/StockBindingPage.d.ts

@@ -0,0 +1 @@
+export default function StockBindingPage(): import("react").JSX.Element;

package/dist/movethewheels/pages/StockObservationsPage.d.ts

@@ -0,0 +1 @@
+export default function StockObservationsPage(): import("react").JSX.Element;

package/dist/movethewheels/pages/TripUtilizationPage.d.ts

@@ -0,0 +1 @@
+export default function TripUtilizationPage(): import("react").JSX.Element;

package/dist/movethewheels/utils/consolidationHistoryTarget.d.ts

@@ -0,0 +1,12 @@
+import { ReuseRecovery, ReuseRecoveryScope } from './reuseRecovery';
+
+export type OriginalConsolidationHistoryTarget = {
+    kind: 'plan';
+    shipmentId: string;
+    planReference: string;
+} | {
+    kind: 'observation' | 'manifest';
+    planId: string;
+};
+/** Retained input supplies read targets only in its original context; it never rebinds a draft. */
+export declare function originalConsolidationHistoryTarget(pending: ReuseRecovery | null, scope: ReuseRecoveryScope | null): OriginalConsolidationHistoryTarget | null;

package/dist/movethewheels/utils/consolidationInput.d.ts

@@ -0,0 +1,15 @@
+import { localProcedureInstant } from './procedureInput';
+
+export declare const consolidationInstant: typeof localProcedureInstant;
+export declare function nullableText(value: string): string | null;
+/** Keep decimal source text exact. Blank facts are unknown, and explicit zero remains zero. */
+export declare function consolidationQuantity(value: string): string | null;
+export declare function sameConsolidationPin(a: {
+    id: string;
+    version: number;
+} | null, b: {
+    id: string;
+    version: number;
+} | null): boolean;
+/** Require the scoped immutable acknowledgement before clearing the original request. */
+export declare function consolidationAcknowledgement(result: Record<string, unknown>, input: Record<string, unknown>, actorId?: string): boolean;

package/dist/movethewheels/utils/consolidationLot.d.ts

@@ -0,0 +1,3 @@
+import { MtwConsolidationLotInput } from '../../generated/consolidation-operations';
+
+export declare function emptyConsolidationLot(): MtwConsolidationLotInput;

package/dist/movethewheels/utils/consolidationPins.d.ts

@@ -0,0 +1,20 @@
+import { ConsolidationContainersQuery, ConsolidationCyclesQuery, ConsolidationShipmentQuery } from '../../generated/consolidation-operations';
+
+export type ConsolidationContextPin = {
+    shipmentId: string;
+    shipmentUpdatedAt: string;
+    cycleId: string;
+    cycleVersion: number;
+    containerId: string;
+};
+export declare function matchesConsolidationContext(pin: ConsolidationContextPin, shipment: ConsolidationShipmentQuery['shipment'], cycle: ConsolidationCyclesQuery['mtwContainerCyclePage']['items'][number] | null): boolean;
+export declare function assertConsolidationPredecessor(pin: {
+    id: string;
+    version: number;
+} | null, current: {
+    id: string;
+    version: number;
+} | null): void;
+export type ConsolidationContainerOption = Pick<ConsolidationContainersQuery['mtwContainerPage']['items'][number], 'id' | 'containerNumber' | 'equipmentType'>;
+/** Retain the selected label across pagination without asserting current source validity. */
+export declare function offPageConsolidationContainer(selectedId: string, selected: ConsolidationContainerOption | null, visible: readonly ConsolidationContainerOption[]): ConsolidationContainerOption | null;

package/dist/movethewheels/utils/consolidationRecovery.d.ts

@@ -0,0 +1,5 @@
+import { ReuseRecovery } from './reuseRecovery';
+
+export declare const CONSOLIDATION_RECOVERY_STORAGE = "movethewheels.consolidation.unresolved.v1";
+export declare function decodeConsolidationRecovery(raw: string | null): ReuseRecovery | null;
+export declare function encodeConsolidationRecovery(attempt: ReuseRecovery): string;

package/dist/movethewheels/utils/consolidationReportHead.d.ts

@@ -0,0 +1,5 @@
+import { ConsolidationObservationsDocument, ConsolidationObservationsQuery, MtwConsolidationReportKind } from '../../generated/consolidation-operations';
+
+type Report = ConsolidationObservationsQuery['mtwConsolidationObservationPage']['items'][number];
+export declare function findConsolidationReportHead(request: <T>(document: typeof ConsolidationObservationsDocument, variables: Record<string, unknown>) => Promise<T>, planId: string, lotId: string, kind: MtwConsolidationReportKind): Promise<Report | null>;
+export {};

package/dist/movethewheels/utils/freeTimeDate.d.ts

@@ -0,0 +1 @@
+export declare function freeTimeIso(value: string): string;

package/dist/movethewheels/utils/freightAcknowledgement.d.ts

@@ -0,0 +1,2 @@
+/** Validate the minimum immutable receipt identity before resolving a retained request. */
+export declare function matchesFreightAcknowledgement(result: unknown, input: Record<string, unknown>): boolean;

package/dist/movethewheels/utils/freightDraft.d.ts

@@ -0,0 +1,36 @@
+import { MtwFreightFactsInput, MtwFreightLineInput, MtwFreightFxInput, SaveMtwFreightEstimateInput } from '../../generated/freight-cost-operations';
+
+export declare const freightCategories: readonly ["BASE_FREIGHT", "FUEL", "PRE_CARRIAGE", "ON_CARRIAGE", "ORIGIN_HANDLING", "DESTINATION_HANDLING", "INSURANCE", "ACCESSORIAL", "TAX_ESTIMATE", "DUTY_ESTIMATE", "BROKER", "FREE_TIME_EXPOSURE", "OTHER"];
+export declare const freightLabel: (value: string) => string;
+export declare const freightNullable: (value: string) => string | null;
+/** Money never passes through Number; sourced fixed amounts must fit the declared scale exactly. */
+export declare function fixedFreightMinor(value: string, digits: number): string | null;
+/** Match supported decimal zero spellings without rounding or accepting invalid quantities. */
+export declare function isFreightDecimalZero(value: string | null | undefined): boolean;
+export declare function freightMoney(minor: string | null | undefined, digits: number): string;
+export declare function freightInstant(value: string): string;
+export declare function freightLocalTime(value: string): string;
+export declare function newFreightLine(): MtwFreightLineInput;
+export declare function newFreightFacts(): MtwFreightFactsInput;
+export declare function newFreightFx(): MtwFreightFxInput;
+export interface FreightDraftPin {
+    shipmentId: string;
+    shipmentUpdatedAt: string;
+    estimateReference: string;
+    previousId: string | null;
+    version: number;
+}
+export declare function freightPinMatches(pin: FreightDraftPin, shipment: {
+    id: string;
+    updatedAt: string;
+} | null | undefined, latest: {
+    id: string;
+    version: number;
+} | null): boolean;
+export declare function freightSaveInput(pin: FreightDraftPin, shipment: {
+    id: string;
+    updatedAt: string;
+} | null | undefined, latest: {
+    id: string;
+    version: number;
+} | null, facts: MtwFreightFactsInput, evidence: SaveMtwFreightEstimateInput['evidence']): Omit<SaveMtwFreightEstimateInput, 'idempotencyKey'>;

package/dist/movethewheels/utils/freightRecovery.d.ts

@@ -0,0 +1,5 @@
+import { ReuseRecovery } from './reuseRecovery';
+
+export declare const FREIGHT_RECOVERY_STORAGE = "movethewheels.freight.unresolved.v1";
+export declare function decodeFreightRecovery(raw: string | null): ReuseRecovery | null;
+export declare function encodeFreightRecovery(attempt: ReuseRecovery): string;

package/dist/movethewheels/utils/graphqlClient.d.ts

@@ -1,3 +1,4 @@
+export type GraphQLAttemptPolicy = 'RETRY_TRANSIENT' | 'SINGLE_ATTEMPT';
 interface GraphQLRequestOptions {
     apiGatewayUrl?: string;
     authToken?: string;
@@ -7,5 +8,5 @@ interface GraphQLRequestOptions {
     actorId?: string;
 }
 export declare function resolveGraphqlUrl(apiGatewayUrl?: string): string;
-export declare function executeGraphQL<TData>(options: GraphQLRequestOptions, query: string, variables?: Record<string, unknown>): Promise<TData>;
+export declare function executeGraphQL<TData>(options: GraphQLRequestOptions, query: string, variables?: Record<string, unknown>, attemptPolicy?: GraphQLAttemptPolicy): Promise<TData>;
 export {};

package/dist/movethewheels/utils/pendingPickDraft.d.ts

@@ -0,0 +1,8 @@
+import { CreateMtwPickTaskIntentInput, PickPreparationQuery } from '../../generated/pending-pick-operations';
+
+type Context = PickPreparationQuery['mtwPickPreparation'];
+export type PendingPickInput = Omit<CreateMtwPickTaskIntentInput, 'idempotencyKey'>;
+export declare function pendingContextSignature(context: Context): string;
+export declare function pendingPickInput(context: Context, count: string, reason: string): PendingPickInput;
+export declare function pendingPickMatches(draftSignature: string, current: Context): boolean;
+export {};

package/dist/movethewheels/utils/procedureInput.d.ts

@@ -0,0 +1,18 @@
+import { MtwProcedureScopeInput, MtwProcedureStep } from '../../generated/logistics-procedure-operations';
+
+export declare const procedureSteps: readonly MtwProcedureStep[];
+export declare const stepLabel: Record<MtwProcedureStep, string>;
+export declare function object(value: unknown): value is Record<string, unknown>;
+export declare function procedureAcknowledgement(result: Record<string, unknown>, input: Record<string, unknown>, actorId?: string): boolean;
+/** Local input never supplies readiness, actor identity, execution or custody facts. */
+export declare function localProcedureInstant(value: string): string;
+export declare function scopeInput(scope: Omit<MtwProcedureScopeInput, 'declaredJurisdictions'> & {
+    declaredJurisdictions: string[];
+}): MtwProcedureScopeInput;
+export declare function chainMatches(pin: {
+    id: string;
+    version: number;
+} | null, current: {
+    id: string;
+    version: number;
+} | null): boolean;

package/dist/movethewheels/utils/procedureRecovery.d.ts

@@ -0,0 +1,5 @@
+import { ReuseRecovery } from './reuseRecovery';
+
+export declare const PROCEDURE_RECOVERY_STORAGE = "movethewheels.procedure.unresolved.v1";
+export declare function decodeProcedureRecovery(raw: string | null): ReuseRecovery | null;
+export declare function encodeProcedureRecovery(attempt: ReuseRecovery): string;

package/dist/movethewheels/utils/reuseAttempt.d.ts

@@ -0,0 +1,7 @@
+/** Stores one submitted intent. Reads may refresh versions without changing an uncertain retry. */
+export interface ReuseAttempt {
+    fingerprint: string;
+    input: Record<string, unknown>;
+    key: string;
+}
+export declare function reuseAttempt(previous: ReuseAttempt | null, operation: string, input: Record<string, unknown>, createKey: () => string): ReuseAttempt;

package/dist/movethewheels/utils/reuseForm.d.ts

@@ -0,0 +1,6 @@
+import { MtwReuseSourceAttestationInput } from '../../generated/empty-reuse-operations';
+import { SelectedEvidence } from '../components/ContainerEvidencePicker';
+
+export declare function reuseText(values: FormData, name: string): string;
+export declare function reuseInteger(values: FormData, name: string): number;
+export declare function readReuseSource(values: FormData, name: string, evidence: SelectedEvidence[]): MtwReuseSourceAttestationInput | undefined;

package/dist/movethewheels/utils/reuseRecovery.d.ts

@@ -0,0 +1,26 @@
+import { DocumentNode } from 'graphql';
+
+export declare const REUSE_RECOVERY_STORAGE = "movethewheels.empty-reuse.unresolved.v1";
+export interface ReuseRecoveryScope {
+    actorId: string;
+    workspaceId: string;
+    tenantId: string;
+    organizationId: string;
+    gateway: string;
+    projectId: string | null;
+}
+export interface ReuseRecovery {
+    version: 1;
+    scope: ReuseRecoveryScope;
+    operation: string;
+    input: Record<string, unknown>;
+    key: string;
+    success: string;
+}
+/** Claims are context comparison metadata only; the gateway remains the authentication authority. */
+export declare function reuseRecoveryScope(actorId: string | undefined, workspaceId: string | undefined, tenantId: string | undefined, gateway: string | undefined, workspaceToken: string | undefined): ReuseRecoveryScope | null;
+/** Stable across token renewal; changing an owner/project context resets unsent forms. */
+export declare function reuseRecoveryContextKey(scope: ReuseRecoveryScope | null): string;
+export declare function sameReuseRecoveryScope(a: ReuseRecoveryScope, b: ReuseRecoveryScope | null): boolean;
+export declare function decodeReuseRecovery(raw: string | null, documents: readonly DocumentNode[]): ReuseRecovery | null;
+export declare function encodeReuseRecovery(value: ReuseRecovery): string;

package/dist/movethewheels/utils/stockBindingForm.d.ts

@@ -0,0 +1,23 @@
+import { RecordMtwStockBindingAssessmentInput, StockSourceContextFragment, StockAssessmentFragment } from '../../generated/stock-binding-operations';
+import { SelectedEvidence } from '../components/ContainerEvidencePicker';
+
+export interface StockDraftPin {
+    inventoryItemId: string;
+    expectedCargoItemId: string;
+    expectedWarehouseId: string;
+    expectedLocationId: string | null;
+    expectedCompositionEpoch: number;
+    expectedInventoryUpdatedAt: string;
+    expectedCargoUpdatedAt: string;
+    expectedWarehouseUpdatedAt: string;
+    expectedLocationUpdatedAt: string | null;
+    expectedPreviousAssessmentId: string | null;
+    expectedVersion: number;
+    label: string;
+}
+export type StockFactDraft = Pick<RecordMtwStockBindingAssessmentInput, 'effectiveAt' | 'facts' | 'evidence'>;
+export declare function stockContextLabel(row: StockSourceContextFragment): string;
+export declare function stockDraftPin(row: StockSourceContextFragment, predecessor: StockAssessmentFragment | null): StockDraftPin;
+export declare function stockContextMatches(pin: StockDraftPin, row: StockSourceContextFragment | null | undefined, predecessor: StockAssessmentFragment | null): boolean;
+export declare function inputForStockDraft(draft: StockFactDraft, pin: StockDraftPin, row: StockSourceContextFragment | null | undefined, predecessor: StockAssessmentFragment | null): Omit<RecordMtwStockBindingAssessmentInput, 'idempotencyKey'>;
+export declare function readStockFactDraft(data: FormData, evidence: SelectedEvidence[]): StockFactDraft;

package/dist/movethewheels/utils/stockBindingLabels.d.ts

@@ -0,0 +1,10 @@
+export declare function stockCompletenessLabel(status: string): string;
+export declare function stockFactLabel(value: string | null | undefined): string;
+export declare function stockMissingFactLabel(value: string): string;
+export declare function stockContinuityLabel(assessment: {
+    inventoryItemId: string;
+    capturedCompositionEpoch?: number | null;
+}, current?: {
+    id: string;
+    compositionEpoch: number;
+} | null): string;

package/dist/movethewheels/utils/stockObservationForm.d.ts

@@ -0,0 +1,5 @@
+import { RecordMtwStockObservationInput } from '../../generated/stock-observation-operations';
+
+/** Blank remains unknown, explicit zero remains zero; no inferred stock adjustment. */
+export declare function reportedCount(value: string): number | null;
+export declare function stockObservationInput(inventoryItemId: string, form: FormData): Omit<RecordMtwStockObservationInput, 'idempotencyKey'>;

package/dist/movethewheels/utils/tripDraftContext.d.ts

@@ -0,0 +1,25 @@
+import { RecordMtwTripUtilizationReportInput } from '../../generated/trip-utilization-operations';
+import { TripReportDraft } from './tripUtilizationForm';
+
+export interface TripDraftContext {
+    routeId: string;
+    routeUpdatedAt: string;
+    vehicleId: string;
+    vehicleUpdatedAt: string;
+    routeName: string;
+    vehicleNumber: string;
+}
+interface RouteContext {
+    id: string;
+    updatedAt: string;
+    vehicleId?: string | null;
+}
+interface VehicleContext {
+    id: string;
+    updatedAt: string;
+}
+export declare function tripRouteStillMatches(pin: TripDraftContext, route: RouteContext | null | undefined): boolean;
+export declare function tripContextStillMatches(pin: TripDraftContext, route: RouteContext | null | undefined, vehicle: VehicleContext | null | undefined): boolean;
+/** Fresh reads verify captured intent; they never replace the vehicle or revisions entered against. */
+export declare function inputForTripDraft(draft: TripReportDraft, pin: TripDraftContext, route: RouteContext | null | undefined, vehicle: VehicleContext | null | undefined): Omit<RecordMtwTripUtilizationReportInput, 'idempotencyKey'>;
+export {};

package/dist/movethewheels/utils/tripUtilizationForm.d.ts

@@ -0,0 +1,6 @@
+import { RecordMtwTripUtilizationReportInput, MtwTripUtilizationBasis, MtwTripUtilizationCoverage } from '../../generated/trip-utilization-operations';
+import { SelectedEvidence } from '../components/ContainerEvidencePicker';
+
+export type TripReportDraft = Omit<RecordMtwTripUtilizationReportInput, 'routeId' | 'vehicleId' | 'expectedRouteUpdatedAt' | 'expectedVehicleUpdatedAt' | 'idempotencyKey'>;
+export declare function tripQuantity(text: string, maximum: number, positive?: boolean): number | null;
+export declare function readTripDraft(values: FormData, ids: string[], basis: MtwTripUtilizationBasis, coverage: MtwTripUtilizationCoverage, evidence: SelectedEvidence[]): TripReportDraft;

package/dist/node_modules/@react-leaflet/core/lib/component.js

@@ -7,9 +7,9 @@ function s(r) {
 		let { instance: o, context: s } = r(n).current;
 		i(a, () => o);
 		let { children: c } = n;
-		return c == null ? null : /* @__PURE__ */ t.createElement(e, { value: s }, c);
+		return c == null ? null : /*#__PURE__*/ t.createElement(e, { value: s }, c);
 	}
-	return /* @__PURE__ */ n(a);
+	return /*#__PURE__*/ n(a);
 }
 function c(e) {
 	function t(t, n) {
@@ -22,16 +22,16 @@ function c(e) {
 			t.children
 		]);
 		let u = l._contentNode;
-		return u ? /* @__PURE__ */ o(t.children, u) : null;
+		return u ? /*#__PURE__*/ o(t.children, u) : null;
 	}
-	return /* @__PURE__ */ n(t);
+	return /*#__PURE__*/ n(t);
 }
 function l(e) {
 	function t(t, n) {
 		let { instance: r } = e(t).current;
 		return i(n, () => r), null;
 	}
-	return /* @__PURE__ */ n(t);
+	return /*#__PURE__*/ n(t);
 }
 //#endregion
 export { s as createContainerComponent, c as createDivOverlayComponent, l as createLeafComponent };