@seedtactics/insight-client 16.4.0

package/dist/cell-status/material-summary.js

@@ -0,0 +1,312 @@
+/* Copyright (c) 2021, John Lenz
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of John Lenz, Black Maple Software, SeedTactics,
+      nor the names of other contributors may be used to endorse or
+      promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+import { LogType } from "../network/api.js";
+import { addDays } from "date-fns";
+import { HashMap, LazySeq, HashSet } from "@seedtactics/immutable-collections";
+import { atom } from "jotai";
+const last30MaterialSummaryRW = atom({
+    matsById: HashMap.empty(),
+    matIdsForJob: HashMap.empty(),
+});
+export const last30MaterialSummary = last30MaterialSummaryRW;
+const specificMonthMaterialSummaryRW = atom({
+    matsById: HashMap.empty(),
+    matIdsForJob: HashMap.empty(),
+});
+export const specificMonthMaterialSummary = specificMonthMaterialSummaryRW;
+export function inproc_mat_to_summary(mat) {
+    return {
+        materialID: mat.materialID,
+        jobUnique: mat.jobUnique,
+        partName: mat.partName,
+        startedProcess1: mat.process > 0,
+        serial: mat.serial,
+        workorderId: mat.workorderId,
+        signaledInspections: mat.signaledInspections,
+        quarantineAfterUnload: mat.quarantineAfterUnload,
+    };
+}
+function process_event(st, e) {
+    let mats = st.matsById;
+    let jobs = st.matIdsForJob;
+    if (e.startofcycle || e.material.length === 0) {
+        return st;
+    }
+    for (const logMat of e.material) {
+        if (logMat.uniq && logMat.uniq !== "") {
+            const forJob = jobs.get(logMat.uniq);
+            if (forJob === undefined) {
+                jobs = jobs.set(logMat.uniq, HashSet.empty().add(logMat.id));
+            }
+            else {
+                if (!forJob.has(logMat.id)) {
+                    jobs = jobs.set(logMat.uniq, forJob.add(logMat.id));
+                }
+            }
+        }
+        const oldMat = mats.get(logMat.id);
+        let mat;
+        if (oldMat !== undefined) {
+            mat = { ...oldMat, last_event: e.endUTC };
+        }
+        else {
+            mat = {
+                materialID: logMat.id,
+                jobUnique: logMat.uniq,
+                partName: logMat.part,
+                last_event: e.endUTC,
+                startedProcess1: false,
+                numProcesses: logMat.numproc,
+                unloaded_processes: {},
+                signaledInspections: [],
+                quarantineAfterUnload: null,
+                completedInspections: {},
+            };
+        }
+        switch (e.type) {
+            case LogType.PartMark:
+                mat = { ...mat, serial: e.result };
+                break;
+            case LogType.OrderAssignment:
+                mat = { ...mat, workorderId: e.result };
+                break;
+            case LogType.Inspection:
+                if (e.result.toLowerCase() === "true" || e.result === "1") {
+                    const inspType = (e.details || {}).InspectionType;
+                    if (inspType) {
+                        mat = {
+                            ...mat,
+                            signaledInspections: [...mat.signaledInspections, inspType],
+                        };
+                    }
+                }
+                break;
+            case LogType.InspectionForce:
+                if (e.result.toLowerCase() === "true" || e.result === "1") {
+                    const inspType = e.program;
+                    mat = {
+                        ...mat,
+                        signaledInspections: [...mat.signaledInspections, inspType],
+                    };
+                }
+                break;
+            case LogType.InspectionResult: {
+                const success = e.result.toLowerCase() == "true" || e.result === "1";
+                mat = {
+                    ...mat,
+                    completedInspections: {
+                        ...mat.completedInspections,
+                        [e.program]: { time: e.endUTC, success },
+                    },
+                    completed_inspect_time: e.endUTC,
+                };
+                break;
+            }
+            case LogType.LoadUnloadCycle:
+                if (e.result === "UNLOAD") {
+                    mat = {
+                        ...mat,
+                        unloaded_processes: { ...mat.unloaded_processes, [logMat.proc]: e.endUTC },
+                        quarantineAfterUnload: false,
+                        currently_quarantined: false, // a load cycle disables quarantine
+                    };
+                    if (logMat.proc === logMat.numproc) {
+                        mat = {
+                            ...mat,
+                            last_unload_time: e.endUTC,
+                            completed_last_proc_machining: true,
+                        };
+                    }
+                    else {
+                        mat = {
+                            ...mat,
+                            last_unload_time: e.endUTC,
+                        };
+                    }
+                }
+                else if (e.result === "LOAD") {
+                    mat = {
+                        ...mat,
+                        startedProcess1: true,
+                        quarantineAfterUnload: false,
+                        currently_quarantined: false, // a load cycle disables quarantine
+                    };
+                }
+                break;
+            case LogType.MachineCycle:
+                // a machine cycle disables quarantine
+                if (mat.currently_quarantined) {
+                    mat = { ...mat, currently_quarantined: false };
+                }
+                break;
+            case LogType.AddToQueue:
+                if (e.program === "Quarantine") {
+                    mat = { ...mat, currently_quarantined: true };
+                }
+                break;
+            case LogType.CloseOut:
+                mat = { ...mat, closeout_completed: e.endUTC, closeout_failed: e.result === "Failed" };
+                break;
+            case LogType.SignalQuarantine:
+                mat = { ...mat, quarantineAfterUnload: true };
+        }
+        mats = mats.set(logMat.id, mat);
+    }
+    return { matsById: mats, matIdsForJob: jobs };
+}
+function filter_old(expire, { matIdsForJob, matsById }) {
+    const matsToRemove = matsById
+        .valuesToLazySeq()
+        .filter((e) => e.last_event < expire)
+        .toRSet((e) => e.materialID);
+    if (matsToRemove.size > 0) {
+        matIdsForJob = matIdsForJob.collectValues((ids) => {
+            const newIds = LazySeq.of(matsToRemove).fold(ids, (i, c) => i.delete(c));
+            if (newIds.size > 0) {
+                return newIds;
+            }
+            else {
+                return null;
+            }
+        });
+    }
+    matsById = matsById.filter((e) => e.last_event >= expire);
+    return { matIdsForJob, matsById };
+}
+function process_swap(swap, st) {
+    let jobs = st.matIdsForJob;
+    const oldMatFromState = st.matsById.get(swap.oldMaterialID) ?? null;
+    const newMatFromState = st.matsById.get(swap.newMaterialID) ?? null;
+    if (oldMatFromState === null)
+        return st;
+    let oldMat = oldMatFromState;
+    let newMat;
+    if (newMatFromState === null) {
+        newMat = {
+            materialID: swap.newMaterialID,
+            jobUnique: oldMat.jobUnique,
+            partName: oldMat.partName,
+            last_event: oldMat.last_event,
+            numProcesses: oldMat.numProcesses,
+            startedProcess1: true,
+            unloaded_processes: {},
+            signaledInspections: [],
+            quarantineAfterUnload: null,
+            completedInspections: {},
+        };
+    }
+    else {
+        newMat = newMatFromState;
+    }
+    if (oldMat.jobUnique && oldMat.jobUnique !== "" && (!newMat.jobUnique || newMat.jobUnique === "")) {
+        // Swap newMat from raw material
+        const forJob = jobs.get(oldMat.jobUnique);
+        if (forJob !== undefined) {
+            jobs = jobs.set(oldMat.jobUnique, forJob.delete(oldMat.materialID).add(newMat.materialID));
+        }
+        newMat = { ...newMat, jobUnique: oldMat.jobUnique };
+        oldMat = { ...oldMat, jobUnique: "" };
+    }
+    const oldMatUnloads = oldMat.unloaded_processes;
+    oldMat = { ...oldMat, unloaded_processes: newMat.unloaded_processes };
+    newMat = { ...newMat, unloaded_processes: oldMatUnloads };
+    for (const evt of swap.editedEvents) {
+        const newMatFromEvt = evt.material.find((m) => m.id === swap.newMaterialID);
+        if (newMatFromEvt) {
+            newMat = {
+                ...newMat,
+                serial: newMatFromEvt.serial ?? newMat.serial,
+                workorderId: newMatFromEvt.workorder ?? newMat.workorderId,
+            };
+        }
+        switch (evt.type) {
+            case LogType.Inspection:
+            case LogType.InspectionForce: {
+                const inspType = evt.program;
+                let inspect;
+                if (evt.result.toLowerCase() === "true" || evt.result === "1") {
+                    inspect = true;
+                }
+                else {
+                    inspect = false;
+                }
+                if (inspect) {
+                    // remove from oldMat, add to newMat
+                    oldMat = {
+                        ...oldMat,
+                        signaledInspections: LazySeq.of(oldMat.signaledInspections)
+                            .filter((i) => i !== inspType)
+                            .toRArray(),
+                    };
+                    newMat = {
+                        ...newMat,
+                        signaledInspections: LazySeq.of([...newMat.signaledInspections, inspType])
+                            .distinct()
+                            .toSortedArray((x) => x),
+                    };
+                }
+            }
+        }
+    }
+    return {
+        matsById: st.matsById.set(oldMat.materialID, oldMat).set(newMat.materialID, newMat),
+        matIdsForJob: jobs,
+    };
+}
+export const setLast30MatSummary = atom(null, (_, set, log) => {
+    set(last30MaterialSummaryRW, (st) => log.reduce(process_event, st));
+});
+export const updateLast30MatSummary = atom(null, (_, set, { evt, now, expire }) => {
+    if (evt.logEntry) {
+        const log = evt.logEntry;
+        set(last30MaterialSummaryRW, (st) => {
+            const newSt = process_event(st, log);
+            if (newSt === st || !expire) {
+                return st;
+            }
+            else {
+                return filter_old(addDays(now, -30), newSt);
+            }
+        });
+    }
+    else if (evt.editMaterialInLog) {
+        const edit = evt.editMaterialInLog;
+        set(last30MaterialSummaryRW, (st) => process_swap(edit, st));
+    }
+});
+export const setSpecificMonthMatSummary = atom(null, (_, set, log) => {
+    set(specificMonthMaterialSummaryRW, log.reduce(process_event, {
+        matsById: HashMap.empty(),
+        matIdsForJob: HashMap.empty(),
+    }));
+});

package/dist/cell-status/names.d.ts

@@ -0,0 +1,19 @@
+import { Atom } from "jotai";
+import { ICurrentStatus, IHistoricData, ILogEntry } from "../network/api.js";
+import type { ServerEventAndTime } from "./loading.js";
+export declare const rawMaterialQueues: Atom<ReadonlySet<string>>;
+export declare const inProcessQueues: Atom<ReadonlySet<string>>;
+export declare const castingNames: Atom<ReadonlySet<string>>;
+export declare const last30InspectionTypes: Atom<ReadonlySet<string>>;
+export declare const updateNames: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};
+export declare const setNamesFromLast30Jobs: import("jotai").WritableAtom<null, [history: Readonly<IHistoricData>], void> & {
+    init: null;
+};
+export declare const setNamesFromLast30Evts: import("jotai").WritableAtom<null, [logs: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};
+export declare const setNamesFromCurrentStatus: import("jotai").WritableAtom<null, [st: Readonly<ICurrentStatus>], void> & {
+    init: null;
+};

package/dist/cell-status/names.js

@@ -0,0 +1,134 @@
+/* Copyright (c) 2021, John Lenz
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of John Lenz, Black Maple Software, SeedTactics,
+      nor the names of other contributors may be used to endorse or
+      promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+import { atom } from "jotai";
+import { LogType, QueueRole } from "../network/api.js";
+import { LazySeq } from "@seedtactics/immutable-collections";
+const rawMaterialQueuesRW = atom(new Set());
+export const rawMaterialQueues = rawMaterialQueuesRW;
+const inProcQueuesRW = atom(new Set());
+export const inProcessQueues = inProcQueuesRW;
+const castingNamesRW = atom(new Set());
+export const castingNames = castingNamesRW;
+const inspectionTypesRW = atom(new Set());
+export const last30InspectionTypes = inspectionTypesRW;
+export const updateNames = atom(null, (get, set, { evt }) => {
+    if (evt.newJobs) {
+        onNewJobs(set, evt.newJobs.jobs);
+    }
+    else if (evt.logEntry) {
+        onLog(set, [evt.logEntry]);
+    }
+    else if (evt.newCurrentStatus) {
+        onCurrentStatus(get, set, evt.newCurrentStatus);
+    }
+});
+export const setNamesFromLast30Jobs = atom(null, (_, set, history) => {
+    onNewJobs(set, Object.values(history.jobs));
+});
+export const setNamesFromLast30Evts = atom(null, (_, set, logs) => onLog(set, logs));
+export const setNamesFromCurrentStatus = atom(null, onCurrentStatus);
+function onNewJobs(set, newJobs) {
+    set(castingNamesRW, (names) => {
+        const newC = new Set();
+        for (const j of newJobs) {
+            for (const path of j.procsAndPaths[0].paths) {
+                if (path.casting && path.casting !== "" && !names.has(path.casting)) {
+                    newC.add(path.casting);
+                }
+            }
+        }
+        if (newC.size === 0) {
+            return names;
+        }
+        else {
+            return new Set([...names, ...newC]);
+        }
+    });
+}
+function onCurrentStatus(get, set, st) {
+    onNewJobs(set, Object.values(st.jobs));
+    const rawMatQueues = get(rawMaterialQueuesRW);
+    const inProc = get(inProcQueuesRW);
+    const newRawQ = new Set();
+    const newInProcQ = new Set();
+    for (const [queue, info] of LazySeq.ofObject(st.queues)) {
+        if (info.role === QueueRole.RawMaterial) {
+            if (!rawMatQueues.has(queue)) {
+                newRawQ.add(queue);
+            }
+        }
+        else if (info.role === QueueRole.InProcessTransfer) {
+            if (!inProc.has(queue)) {
+                newInProcQ.add(queue);
+            }
+        }
+    }
+    if (newRawQ.size > 0) {
+        set(rawMaterialQueuesRW, new Set([...rawMatQueues, ...newRawQ]));
+    }
+    if (newInProcQ.size > 0) {
+        set(inProcQueuesRW, new Set([...inProc, ...newInProcQ]));
+    }
+}
+function onLog(set, evts) {
+    set(inspectionTypesRW, (inspTypes) => {
+        const newC = new Set();
+        for (const evt of evts) {
+            switch (evt.type) {
+                case LogType.Inspection:
+                    {
+                        const inspType = (evt.details || {}).InspectionType;
+                        if (inspType && !inspTypes.has(inspType)) {
+                            newC.add(inspType);
+                        }
+                    }
+                    break;
+                case LogType.InspectionForce:
+                case LogType.InspectionResult:
+                    {
+                        const inspType = evt.program;
+                        if (!inspTypes.has(inspType)) {
+                            newC.add(inspType);
+                        }
+                    }
+                    break;
+            }
+        }
+        if (newC.size === 0) {
+            return inspTypes;
+        }
+        else {
+            return new Set([...inspTypes, ...newC]);
+        }
+    });
+}

package/dist/cell-status/pallet-cycles.d.ts

@@ -0,0 +1,24 @@
+import { ILogEntry, ILogMaterial } from "../network/api.js";
+import { HashMap } from "@seedtactics/immutable-collections";
+import type { ServerEventAndTime } from "./loading.js";
+import { Atom } from "jotai";
+export interface PalletCycleData {
+    readonly cntr: number;
+    readonly x: Date;
+    readonly y: number;
+    readonly active: number;
+    readonly mats: ReadonlyArray<Readonly<ILogMaterial>>;
+}
+export type PalletCyclesByCntr = HashMap<number, PalletCycleData>;
+export type PalletCyclesByPallet = HashMap<number, PalletCyclesByCntr>;
+export declare const last30PalletCycles: Atom<PalletCyclesByPallet>;
+export declare const specificMonthPalletCycles: Atom<PalletCyclesByPallet>;
+export declare const setLast30PalletCycles: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};
+export declare const updateLast30PalletCycles: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};
+export declare const setSpecificMonthPalletCycles: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};

package/dist/cell-status/pallet-cycles.js

@@ -0,0 +1,78 @@
+/* Copyright (c) 2021, John Lenz
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of John Lenz, Black Maple Software, SeedTactics,
+      nor the names of other contributors may be used to endorse or
+      promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+import { addDays } from "date-fns";
+import { LogType } from "../network/api.js";
+import { LazySeq, HashMap } from "@seedtactics/immutable-collections";
+import { durationToMinutes } from "../util/parseISODuration.js";
+import { atom } from "jotai";
+const last30PalletCyclesRW = atom(HashMap.empty());
+export const last30PalletCycles = last30PalletCyclesRW;
+const specificMonthPalletCyclesRW = atom(HashMap.empty());
+export const specificMonthPalletCycles = specificMonthPalletCyclesRW;
+function logToPalletCycle(c) {
+    return {
+        cntr: c.counter,
+        x: c.endUTC,
+        y: durationToMinutes(c.elapsed),
+        active: durationToMinutes(c.active),
+        mats: c.material,
+    };
+}
+export const setLast30PalletCycles = atom(null, (_, set, log) => {
+    set(last30PalletCyclesRW, (oldCycles) => oldCycles.union(LazySeq.of(log)
+        .filter((c) => !c.startofcycle && c.type === LogType.PalletCycle && c.pal !== 0)
+        .toLookupMap((c) => c.pal, (c) => c.counter, logToPalletCycle), (e1, e2) => e1.union(e2)));
+});
+export const updateLast30PalletCycles = atom(null, (_, set, { evt, now, expire }) => {
+    if (evt.logEntry &&
+        !evt.logEntry.startofcycle &&
+        evt.logEntry.type === LogType.PalletCycle &&
+        evt.logEntry.pal !== 0) {
+        const log = evt.logEntry;
+        set(last30PalletCyclesRW, (oldCycles) => {
+            if (expire) {
+                const thirtyDaysAgo = addDays(now, -30);
+                oldCycles = oldCycles.collectValues((es) => {
+                    const newEs = es.filter((e) => e.x >= thirtyDaysAgo);
+                    return newEs.size > 0 ? newEs : null;
+                });
+            }
+            return oldCycles.modify(log.pal, (old) => (old ?? HashMap.empty()).set(log.counter, logToPalletCycle(log)));
+        });
+    }
+});
+export const setSpecificMonthPalletCycles = atom(null, (_, set, log) => {
+    set(specificMonthPalletCyclesRW, LazySeq.of(log)
+        .filter((c) => !c.startofcycle && c.type === LogType.PalletCycle && c.pal !== 0)
+        .toLookupMap((c) => c.pal, (c) => c.counter, logToPalletCycle));
+});

package/dist/cell-status/rebookings.d.ts

@@ -0,0 +1,30 @@
+import { Atom } from "jotai";
+import { ServerEventAndTime } from "./loading";
+import { ILogEntry, IRebooking, IRecentHistoricData } from "../network/api";
+import { OrderedMap } from "@seedtactics/immutable-collections";
+export declare const last30Rebookings: Atom<OrderedMap<string, Readonly<IRebooking>>>;
+export declare const canceledRebookings: Atom<OrderedMap<string, Date>>;
+type ScheduledBooking = {
+    readonly scheduledTime: Date;
+    readonly jobUnique: string;
+};
+export declare const last30ScheduledBookings: Atom<OrderedMap<string, ScheduledBooking>>;
+export declare const setLast30Rebookings: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};
+export declare const setLast30RebookingJobs: import("jotai").WritableAtom<null, [historic: Readonly<IRecentHistoricData>], void> & {
+    init: null;
+};
+export declare const updateLast30Rebookings: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};
+export declare function useCancelRebooking(): [(bookingId: string) => Promise<void>, boolean];
+export type NewRebooking = {
+    readonly part: string;
+    readonly qty?: number;
+    readonly workorder?: string | null;
+    readonly priority?: number | null;
+    readonly notes?: string;
+};
+export declare function useNewRebooking(): [(n: NewRebooking) => Promise<void>, boolean];
+export {};