@seedtactics/insight-client 16.4.0

package/dist/components/quality/QualityMaterial.js

@@ -0,0 +1,169 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/* Copyright (c) 2022, 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 { useState } from "react";
+import { CircularProgress, Stack, TextField, Button, Stepper, Step, StepLabel, Typography, } from "@mui/material";
+import * as matDetails from "../../cell-status/material-details.js";
+import { MaterialDetailTitle, MaterialDetailContent, MaterialLoading } from "../station-monitor/Material.js";
+import { buildPathString, extractPath } from "../../data/results.inspection.js";
+import { startOfToday, addDays, startOfDay, endOfDay } from "date-fns";
+import { ApiException, LogType } from "../../network/api.js";
+import { InspectionSankey } from "../analysis/InspectionSankey.js";
+import { useIsDemo, useSetTitle } from "../routes.js";
+import { extendRange, inspectionLogEntries, pathLookupRange } from "../../data/path-lookup.js";
+import { DisplayLoadingAndError } from "../ErrorsAndLoading.js";
+import { LogBackend } from "../../network/backend.js";
+import { LazySeq } from "@seedtactics/immutable-collections";
+import { RecentFailedInspectionsTable } from "./RecentFailedInspections.js";
+import { useAtom, useAtomValue, useSetAtom } from "jotai";
+import { loadable } from "jotai/utils";
+function SerialLookup() {
+    const demo = useIsDemo();
+    const setMatToShow = useSetAtom(matDetails.materialDialogOpen);
+    const [serial, setSerial] = useState(demo ? "00000000i9" : "");
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    function lookup() {
+        if (serial && serial !== "") {
+            setLoading(true);
+            setError(null);
+            LogBackend.materialForSerial(serial)
+                .then((mats) => {
+                const mat = LazySeq.of(mats).maxBy((m) => m.materialID);
+                if (mat) {
+                    setMatToShow({ type: "MatDetails", details: mat });
+                    setSerial("");
+                    setError(null);
+                }
+                else {
+                    setError("No material found with serial " + serial);
+                }
+            })
+                .catch((e) => {
+                if (ApiException.isApiException(e)) {
+                    setError(e.response);
+                }
+                else if (e instanceof Error) {
+                    setError(e.message);
+                }
+                else {
+                    setError(e.toString());
+                }
+            })
+                .finally(() => setLoading(false));
+        }
+    }
+    return (_jsxs(_Fragment, { children: [_jsxs(Stack, { direction: "row", spacing: 2, alignItems: "center", marginLeft: "auto", marginRight: "auto", children: [_jsx("div", { children: _jsx(TextField, { label: serial === "" ? "Serial" : "Serial (press enter)", value: serial, onChange: (e) => setSerial(e.target.value), onKeyPress: (e) => {
+                                if (e.key === "Enter" && serial !== "") {
+                                    e.preventDefault();
+                                    lookup();
+                                }
+                            } }) }), _jsx("div", { children: _jsx(Button, { variant: "contained", color: "secondary", disabled: serial === "" || loading, onClick: lookup, children: loading ? (_jsxs(Stack, { direction: "row", spacing: 2, children: [_jsx(CircularProgress, {}), " Searching"] })) : (_jsx(_Fragment, { children: "Lookup" })) }) })] }), error && error !== "" ? _jsx("div", { children: error }) : undefined] }));
+}
+function lastMachineTime(evts) {
+    const first = evts[0];
+    if (first === undefined) {
+        return startOfToday();
+    }
+    let lastEnd = first.endUTC;
+    for (const e of evts) {
+        if (e.type === LogType.MachineCycle) {
+            lastEnd = e.endUTC;
+        }
+    }
+    return lastEnd;
+}
+function DetailsStepTitle() {
+    const matL = useAtomValue(loadable(matDetails.materialInDialogInfo));
+    const matEvents = useAtomValue(matDetails.materialInDialogEvents);
+    const mat = matL.state === "hasData" ? matL.data : null;
+    if (mat) {
+        return (_jsx(MaterialDetailTitle, { partName: mat.partName, serial: mat.serial, subtitle: "Path " +
+                buildPathString(extractPath(matEvents)) +
+                " at " +
+                lastMachineTime(matEvents).toLocaleString() }));
+    }
+    else {
+        return _jsx("div", { children: "Serial Details" });
+    }
+}
+function DetailsStepButtons({ setStep }) {
+    const matL = useAtomValue(loadable(matDetails.materialInDialogInfo));
+    const mat = matL.state === "hasData" ? matL.data : null;
+    const matEvents = useAtomValue(matDetails.materialInDialogEvents);
+    const setSearchRange = useSetAtom(pathLookupRange);
+    const setMatToShow = useSetAtom(matDetails.materialDialogOpen);
+    return (_jsxs(Stack, { direction: "row", spacing: 2, mt: "2em", children: [mat ? (_jsx(Button, { variant: "contained", color: "secondary", onClick: () => {
+                    const d = lastMachineTime(matEvents);
+                    setSearchRange({
+                        part: mat?.partName ?? "",
+                        curStart: startOfDay(addDays(d, -5)),
+                        curEnd: endOfDay(addDays(d, 5)),
+                    });
+                    setStep(2);
+                }, children: "Lookup Similar Paths" })) : undefined, _jsx(Button, { variant: "contained", style: { marginLeft: "2em" }, onClick: () => {
+                    setMatToShow(null);
+                    setSearchRange(null);
+                    setStep(0);
+                }, children: "Reset" })] }));
+}
+function PathLookupStep(props) {
+    const mat = useAtomValue(matDetails.materialInDialogInfo);
+    const matEvents = useAtomValue(matDetails.materialInDialogEvents);
+    const [searchRange, setSearchRange] = useAtom(pathLookupRange);
+    const logs = useAtomValue(inspectionLogEntries);
+    const setMatToShow = useSetAtom(matDetails.materialDialogOpen);
+    if (mat === null)
+        return null;
+    function extendDateRange(numDays) {
+        setSearchRange(extendRange(numDays));
+    }
+    return (_jsxs("div", { children: [_jsx(InspectionSankey, { inspectionlogs: logs, restrictToPart: mat.partName, subtitle: "Paths for " + mat.partName + " around " + lastMachineTime(matEvents).toLocaleString(), default_date_range: searchRange ? [searchRange.curStart, searchRange.curEnd] : [], zoomType: searchRange ? "ExtendDays" : undefined, extendDateRange: extendDateRange, hideOpenDetailColumn: true, onlyTable: true }), _jsx(Button, { variant: "contained", style: { marginTop: "2em" }, onClick: () => {
+                    setMatToShow(null);
+                    setSearchRange(null);
+                    props.setStep(0);
+                }, children: "Reset" })] }));
+}
+export function PartLookupStepper() {
+    const [origStep, setStep] = useState(0);
+    const matToShow = useAtomValue(matDetails.materialDialogOpen);
+    let step = origStep;
+    if (step === 0 && matToShow) {
+        step = 1;
+    }
+    return (_jsxs(Stack, { direction: "column", spacing: 2, children: [_jsxs(Stepper, { activeStep: step, orientation: "horizontal", children: [_jsx(Step, { children: _jsx(StepLabel, { children: "Select Material" }) }), _jsx(Step, { children: _jsx(StepLabel, { children: _jsx(DetailsStepTitle, {}) }) }), _jsx(Step, { children: _jsx(StepLabel, { children: "Lookup similar paths" }) })] }), step === 0 ? (_jsxs(Stack, { direction: "column", spacing: 4, children: [_jsx(Typography, { children: "Enter a serial number, scan a barcode, or click on a material in the table below to see details." }), _jsx(SerialLookup, {}), _jsx(RecentFailedInspectionsTable, {})] })) : step === 1 ? (_jsxs(_Fragment, { children: [_jsx(DisplayLoadingAndError, { fallback: _jsx(MaterialLoading, {}), children: _jsx(MaterialDetailContent, {}) }), _jsx(DetailsStepButtons, { setStep: setStep })] })) : step === 2 ? (_jsx(DisplayLoadingAndError, { children: _jsx(PathLookupStep, { setStep: setStep }) })) : undefined] }));
+}
+export function QualityMaterialPage() {
+    useSetTitle("Quality Material");
+    return (_jsx("main", { style: { padding: "24px" }, children: _jsx(PartLookupStepper, {}) }));
+}

package/dist/components/quality/QualityPaths.d.ts

@@ -0,0 +1 @@
+export declare const QualityPaths: import("react").NamedExoticComponent<object>;

package/dist/components/quality/QualityPaths.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* Copyright (c) 2023, 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 { memo, useMemo } from "react";
+import { addDays, startOfToday } from "date-fns";
+import { InspectionSankey } from "../analysis/InspectionSankey.js";
+import { last30Inspections } from "../../cell-status/inspections.js";
+import { useSetTitle } from "../routes.js";
+import { useAtomValue } from "jotai";
+export const QualityPaths = memo(function SelectedInspections() {
+    useSetTitle("Paths");
+    const inspections = useAtomValue(last30Inspections);
+    const filtered = useMemo(() => {
+        const today = startOfToday();
+        const start = addDays(today, -6);
+        const end = addDays(today, 1);
+        return inspections.collectValues((log) => {
+            const newLog = log.filter((e) => e.time >= start && e.time <= end);
+            return newLog.size === 0 ? null : newLog;
+        });
+    }, [inspections]);
+    return (_jsx(InspectionSankey, { inspectionlogs: filtered, default_date_range: [addDays(startOfToday(), -6), addDays(startOfToday(), 1)], subtitle: "Paths from the last 7 days" }));
+});

package/dist/components/quality/RecentFailedInspections.d.ts

@@ -0,0 +1 @@
+export declare function RecentFailedInspectionsTable(): import("react/jsx-runtime").JSX.Element;

package/dist/components/quality/RecentFailedInspections.js

@@ -0,0 +1,123 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/* Copyright (c) 2023, 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 { useMemo } from "react";
+import { Box, Typography } from "@mui/material";
+import { Tooltip } from "@mui/material";
+import { IconButton } from "@mui/material";
+import { Table } from "@mui/material";
+import { ImportExport } from "@mui/icons-material";
+import { extractFailedInspections, copyFailedInspectionsToClipboard, } from "../../data/results.inspection.js";
+import { LazySeq } from "@seedtactics/immutable-collections";
+import { addDays, startOfToday } from "date-fns";
+import { DataTableHead, DataTableBody, DataTableActions, useColSort, useTablePage, } from "../analysis/DataTable.js";
+import { materialDialogOpen } from "../../cell-status/material-details.js";
+import { useIsDemo } from "../routes.js";
+import { last30Inspections } from "../../cell-status/inspections.js";
+import { useAtomValue, useSetAtom } from "jotai";
+var ColumnId;
+(function (ColumnId) {
+    ColumnId[ColumnId["Date"] = 0] = "Date";
+    ColumnId[ColumnId["Part"] = 1] = "Part";
+    ColumnId[ColumnId["InspType"] = 2] = "InspType";
+    ColumnId[ColumnId["Serial"] = 3] = "Serial";
+    ColumnId[ColumnId["Workorder"] = 4] = "Workorder";
+})(ColumnId || (ColumnId = {}));
+const columns = [
+    {
+        id: ColumnId.Date,
+        numeric: false,
+        label: "Date",
+        getDisplay: (c) => c.time.toLocaleString(),
+        getForSort: (c) => c.time.getTime(),
+    },
+    {
+        id: ColumnId.Part,
+        numeric: false,
+        label: "Part",
+        getDisplay: (c) => c.part,
+    },
+    {
+        id: ColumnId.InspType,
+        numeric: false,
+        label: "Inspection",
+        getDisplay: (c) => c.inspType,
+    },
+    {
+        id: ColumnId.Serial,
+        numeric: false,
+        label: "Serial",
+        getDisplay: (c) => c.serial || "",
+    },
+    {
+        id: ColumnId.Workorder,
+        numeric: false,
+        label: "Workorder",
+        getDisplay: (c) => c.workorder || "",
+    },
+];
+function RecentFailedTable(props) {
+    const demo = useIsDemo();
+    const sort = useColSort(ColumnId.Date, columns);
+    const tpage = useTablePage();
+    const setMatToShow = useSetAtom(materialDialogOpen);
+    const curPage = Math.min(tpage.page, Math.ceil(props.failed.length / tpage.rowsPerPage));
+    const points = LazySeq.of(props.failed).sortBy(sort.sortOn);
+    return (_jsxs(_Fragment, { children: [_jsxs(Table, { children: [_jsx(DataTableHead, { columns: columns, sort: sort, showDetailsCol: !demo }), _jsx(DataTableBody, { columns: columns, pageData: points.drop(curPage * tpage.rowsPerPage).take(tpage.rowsPerPage), rowsPerPage: tpage.rowsPerPage, onClickDetails: demo
+                            ? undefined
+                            : (_, row) => {
+                                setMatToShow({
+                                    type: "MatSummary",
+                                    summary: {
+                                        materialID: row.materialID,
+                                        partName: row.part,
+                                        serial: row.serial,
+                                        workorderId: row.workorder,
+                                    },
+                                });
+                            } })] }), _jsx(DataTableActions, { tpage: { ...tpage, page: curPage }, count: props.failed.length })] }));
+}
+export function RecentFailedInspectionsTable() {
+    const inspections = useAtomValue(last30Inspections);
+    const failed = useMemo(() => {
+        const today = startOfToday();
+        const allEvts = LazySeq.of(inspections).flatMap(([_, evts]) => evts.valuesToLazySeq());
+        return extractFailedInspections(allEvts, addDays(today, -4), addDays(today, 1));
+    }, [inspections]);
+    return (_jsxs("div", { children: [_jsxs(Box, { component: "nav", sx: {
+                    display: "flex",
+                    minHeight: "2.5em",
+                    alignItems: "center",
+                    maxWidth: "calc(100vw - 24px - 24px)",
+                }, children: [_jsx(Typography, { variant: "subtitle1", children: "Inspections marked as failed in the last 5 days" }), _jsx(Box, { flexGrow: 1 }), _jsx(Tooltip, { title: "Copy to Clipboard", children: _jsx(IconButton, { style: { height: "25px", paddingTop: 0, paddingBottom: 0 }, onClick: () => copyFailedInspectionsToClipboard(failed), size: "large", children: _jsx(ImportExport, {}) }) })] }), _jsx(RecentFailedTable, { failed: failed })] }));
+}

package/dist/components/routes.d.ts

@@ -0,0 +1,170 @@
+import "urlpattern-polyfill";
+export declare enum RouteLocation {
+    ChooseMode = "/",
+    Station_LoadMonitor = "/station/loadunload/:num",
+    Station_InspectionMonitor = "/station/inspection",
+    Station_InspectionMonitorWithType = "/station/inspection/:type",
+    Station_Closeout = "/station/closeout",
+    Station_Queues = "/station/queues",
+    Station_Overview = "/station/overview",
+    Operations_Dashboard = "/operations",
+    Operations_LoadOutliers = "/operations/load-outliers",
+    Operations_LoadHours = "/operations/load-hours",
+    Operations_LoadCycles = "/operations/load-cycles",
+    Operations_MachineOutliers = "/operations/machine-outliers",
+    Operations_MachineHours = "/operations/machine-hours",
+    Operations_MachineCycles = "/operations/machine-cycles",
+    Operations_SystemOverview = "/operations/system-overview",
+    Operations_AllMaterial = "/operations/material",
+    Operations_RecentSchedules = "/operations/recent-schedules",
+    Operations_CurrentWorkorders = "/operations/current-workorders",
+    Operations_Production = "/operations/recent-production",
+    Operations_Tools = "/operations/tools",
+    Operations_Programs = "/operations/programs",
+    Operations_Quality = "/operations/quality",
+    Operations_Inspections = "/operations/inspections",
+    Operations_CloseoutReport = "/operations/closeout",
+    Operations_Rebookings = "/analysis/rebookings",
+    Operations_Parts = "/operations/parts",
+    Engineering_Cycles = "/engineering",
+    Engineering_Hours = "/engineering/hours",
+    Engineering_Outliers = "/engineering/outliers",
+    Quality_Dashboard = "/quality",
+    Quality_Paths = "/quality/paths",
+    Quality_Quarantine = "/quality/quarantine",
+    Tools_Dashboard = "/tools",
+    Tools_Programs = "/tools/programs",
+    Analysis_Buffers = "/analysis/buffers",
+    Analysis_StationOEE = "/analysis/station-oee",
+    Analysis_PartsCompleted = "/analysis/parts-completed",
+    Analysis_MachineCycles = "/analysis/machine-cycles",
+    Analysis_LoadCycles = "/analysis/load-cycles",
+    Analysis_PalletCycles = "/analysis/pallet-cycles",
+    Analysis_Schedules = "/analysis/schedules",
+    Analysis_Quality = "/analysis/quality",
+    Analysis_ToolReplacements = "/analysis/tool-replacements",
+    Analysis_CostPercents = "/analysis/cost-percents",
+    Analysis_CostPerPiece = "/analysis/cost",
+    Sales_Dashboard = "/sales",
+    Sales_ProjectedUsage = "/sales/projected-usage",
+    VerboseLogging = "/logging",
+    Client_Custom = "/client/:custom+"
+}
+export type RouteState = {
+    route: RouteLocation.ChooseMode;
+} | {
+    route: RouteLocation.Station_LoadMonitor;
+    loadNum: number;
+    queues: ReadonlyArray<string>;
+    completed: boolean;
+} | {
+    route: RouteLocation.Station_InspectionMonitor;
+} | {
+    route: RouteLocation.Station_InspectionMonitorWithType;
+    readonly inspType: string;
+} | {
+    route: RouteLocation.Station_Closeout;
+} | {
+    route: RouteLocation.Station_Queues;
+    readonly queues: ReadonlyArray<string>;
+} | {
+    route: RouteLocation.Station_Overview;
+} | {
+    route: RouteLocation.Operations_Dashboard;
+} | {
+    route: RouteLocation.Operations_LoadOutliers;
+} | {
+    route: RouteLocation.Operations_LoadHours;
+} | {
+    route: RouteLocation.Operations_LoadCycles;
+} | {
+    route: RouteLocation.Operations_MachineOutliers;
+} | {
+    route: RouteLocation.Operations_MachineHours;
+} | {
+    route: RouteLocation.Operations_MachineCycles;
+} | {
+    route: RouteLocation.Operations_SystemOverview;
+} | {
+    route: RouteLocation.Operations_AllMaterial;
+} | {
+    route: RouteLocation.Operations_RecentSchedules;
+} | {
+    route: RouteLocation.Operations_CurrentWorkorders;
+    readonly workorder?: string;
+} | {
+    route: RouteLocation.Operations_Production;
+} | {
+    route: RouteLocation.Operations_Tools;
+} | {
+    route: RouteLocation.Operations_Programs;
+} | {
+    route: RouteLocation.Operations_Quality;
+} | {
+    route: RouteLocation.Operations_Inspections;
+} | {
+    route: RouteLocation.Operations_CloseoutReport;
+} | {
+    route: RouteLocation.Operations_Rebookings;
+} | {
+    route: RouteLocation.Operations_Parts;
+} | {
+    route: RouteLocation.Engineering_Cycles;
+} | {
+    route: RouteLocation.Engineering_Outliers;
+} | {
+    route: RouteLocation.Engineering_Hours;
+} | {
+    route: RouteLocation.Quality_Dashboard;
+} | {
+    route: RouteLocation.Quality_Paths;
+} | {
+    route: RouteLocation.Quality_Quarantine;
+} | {
+    route: RouteLocation.Tools_Dashboard;
+} | {
+    route: RouteLocation.Tools_Programs;
+} | {
+    route: RouteLocation.Analysis_Buffers;
+} | {
+    route: RouteLocation.Analysis_StationOEE;
+} | {
+    route: RouteLocation.Analysis_PartsCompleted;
+} | {
+    route: RouteLocation.Analysis_Quality;
+} | {
+    route: RouteLocation.Analysis_ToolReplacements;
+} | {
+    route: RouteLocation.Analysis_MachineCycles;
+} | {
+    route: RouteLocation.Analysis_LoadCycles;
+} | {
+    route: RouteLocation.Analysis_PalletCycles;
+} | {
+    route: RouteLocation.Analysis_CostPerPiece;
+} | {
+    route: RouteLocation.Analysis_Schedules;
+} | {
+    route: RouteLocation.Analysis_CostPercents;
+} | {
+    route: RouteLocation.Sales_Dashboard;
+} | {
+    route: RouteLocation.Sales_ProjectedUsage;
+} | {
+    route: RouteLocation.VerboseLogging;
+} | {
+    route: RouteLocation.Client_Custom;
+    readonly custom: ReadonlyArray<string>;
+};
+export declare const isDemoAtom: import("jotai").PrimitiveAtom<boolean> & {
+    init: boolean;
+};
+export declare const currentRoute: import("jotai").WritableAtom<RouteState, [to: RouteState], void>;
+export declare function AppLink({ to, children }: {
+    to: RouteState;
+    children: React.ReactNode;
+}): React.ReactElement;
+export declare function useWatchHistory(): void;
+export declare function useIsDemo(): boolean;
+export declare function useSetTitle(title: string): void;
+export declare function helpUrl(r: RouteState): string;