@seedtactics/insight-client 16.4.0

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

@@ -0,0 +1,145 @@
+/* Copyright (c) 2024, 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 { calcElapsedForCycles, isOutlier, last30EstimatedCycleTimes, PartAndStationOperation, specificMonthEstimatedCycleTimes, } from "./estimated-cycle-times.js";
+import { durationToMinutes } from "../util/parseISODuration.js";
+import { addDays } from "date-fns";
+import { HashMap } from "@seedtactics/immutable-collections";
+import { atom } from "jotai";
+export function stat_name_and_num(stationGroup, stationNumber) {
+    if (stationGroup.startsWith("Inspect")) {
+        return stationGroup;
+    }
+    else {
+        return stationGroup + " #" + stationNumber.toString();
+    }
+}
+const last30StationCyclesRW = atom(HashMap.empty());
+export const last30StationCycles = last30StationCyclesRW;
+const specificMonthStationCyclesRW = atom(HashMap.empty());
+export const specificMonthStationCycles = specificMonthStationCyclesRW;
+function convertLogToCycle(estimatedCycleTimes, cycle, elapsedPerMat) {
+    if (cycle.startofcycle ||
+        (cycle.type !== LogType.LoadUnloadCycle && cycle.type !== LogType.MachineCycle) ||
+        cycle.loc === "") {
+        return null;
+    }
+    const part = cycle.material.length > 0 ? cycle.material[0].part : "";
+    const stats = cycle.material.length > 0
+        ? estimatedCycleTimes.get(PartAndStationOperation.ofLogCycle(cycle))
+        : undefined;
+    let activeMins = durationToMinutes(cycle.active);
+    if (cycle.active === "" || activeMins <= 0 || cycle.material.length == 0) {
+        activeMins = (stats?.expectedCycleMinutesForSingleMat ?? 0) * cycle.material.length;
+    }
+    return {
+        endTime: cycle.endUTC,
+        elapsedMinsPerMaterial: elapsedPerMat,
+        cntr: cycle.counter,
+        activeMinutes: activeMins,
+        medianCycleMinutes: (stats?.medianMinutesForSingleMat ?? 0) * cycle.material.length,
+        MAD_aboveMinutes: stats?.MAD_aboveMinutes ?? 0,
+        part: part,
+        pallet: cycle.pal,
+        material: cycle.material,
+        isLabor: cycle.type === LogType.LoadUnloadCycle,
+        isOutlier: stats ? isOutlier(stats, elapsedPerMat) : false,
+        stationGroup: cycle.loc,
+        stationNumber: cycle.locnum,
+        operation: cycle.type === LogType.LoadUnloadCycle ? cycle.result : cycle.program,
+        operator: cycle.details ? cycle.details.operator || "" : "",
+    };
+}
+function convertOldLogsToCycles(estimateCycleTimes, log) {
+    return calcElapsedForCycles(log)
+        .collect((c) => convertLogToCycle(estimateCycleTimes, c.cycle, c.elapsedForSingleMaterialMinutes))
+        .buildHashMap((c) => c.cntr);
+}
+function process_swap(swap, partCycles) {
+    for (const changed of swap.editedEvents) {
+        const c = partCycles.get(changed.counter);
+        if (c !== undefined) {
+            const newC = { ...c, material: changed.material };
+            partCycles = partCycles.set(changed.counter, newC);
+        }
+    }
+    return partCycles;
+}
+export const setLast30StationCycles = atom(null, (get, set, log) => {
+    const estimatedCycleTimes = get(last30EstimatedCycleTimes);
+    set(last30StationCyclesRW, (oldCycles) => oldCycles.union(convertOldLogsToCycles(estimatedCycleTimes, log)));
+});
+export const updateLast30StationCycles = atom(null, (get, set, { evt, now, expire }) => {
+    if (evt.logEntry && evt.logEntry.type === LogType.InvalidateCycle) {
+        const cntrs = evt.logEntry.details?.["EditedCounters"];
+        const invalidatedCycles = cntrs ? new Set(cntrs.split(",").map((i) => parseInt(i))) : new Set();
+        if (invalidatedCycles.size > 0) {
+            set(last30StationCyclesRW, (cycles) => {
+                for (const invalid of invalidatedCycles) {
+                    const c = cycles.get(invalid);
+                    if (c !== undefined) {
+                        cycles = cycles.set(invalid, { ...c, activeMinutes: 0 });
+                    }
+                }
+                return cycles;
+            });
+        }
+    }
+    else if (evt.logEntry) {
+        const estimatedCycleTimes = get(last30EstimatedCycleTimes);
+        // new events arriving over websocket are garuanteed to use the new method of calculating elapsed time
+        // where the server already splits the elapsed time among a chunk, so no need to chunk here
+        const elapsedPerMat = evt.logEntry.material.length > 0
+            ? durationToMinutes(evt.logEntry.elapsed) / evt.logEntry.material.length
+            : 0;
+        const converted = convertLogToCycle(estimatedCycleTimes, evt.logEntry, elapsedPerMat);
+        if (!converted)
+            return;
+        set(last30StationCyclesRW, (cycles) => {
+            if (expire) {
+                const thirtyDaysAgo = addDays(now, -30);
+                cycles = cycles.filter((e) => e.endTime >= thirtyDaysAgo);
+            }
+            cycles = cycles.set(converted.cntr, converted);
+            return cycles;
+        });
+    }
+    else if (evt.editMaterialInLog) {
+        const edit = evt.editMaterialInLog;
+        set(last30StationCyclesRW, (oldCycles) => process_swap(edit, oldCycles));
+    }
+});
+export const setSpecificMonthStationCycles = atom(null, (get, set, log) => {
+    const estimatedCycleTimes = get(specificMonthEstimatedCycleTimes);
+    set(specificMonthStationCyclesRW, convertOldLogsToCycles(estimatedCycleTimes, log));
+});

package/dist/cell-status/tool-replacements.d.ts

@@ -0,0 +1,44 @@
+import { ILogEntry } from "../network/api.js";
+import { OrderedMap, HashableObj } from "@seedtactics/immutable-collections";
+import type { ServerEventAndTime } from "./loading.js";
+export type ToolReplacement = {
+    readonly tool: string;
+    readonly pocket: number;
+    readonly type: "ReplaceBeforeCycleStart";
+    readonly useAtReplacement: number | null;
+    readonly cntAtReplacement: number | null;
+} | {
+    readonly tool: string;
+    readonly pocket: number;
+    readonly type: "ReplaceInCycle";
+    readonly totalUseAtBeginningOfCycle: number | null;
+    readonly totalUseAtEndOfCycle: number | null;
+    readonly totalCntAtBeginningOfCycle: number | null;
+    readonly totalCntAtEndOfCycle: number | null;
+};
+export type ToolReplacements = {
+    readonly time: Date;
+    readonly replacements: ReadonlyArray<ToolReplacement>;
+};
+export declare class StationGroupAndNum implements HashableObj {
+    readonly group: string;
+    readonly num: number;
+    constructor(group: string, num: number);
+    static ofLogCycle(e: Readonly<ILogEntry>): StationGroupAndNum;
+    hash(): number;
+    compare(other: StationGroupAndNum): number;
+    toString(): string;
+}
+export type ToolReplacementsByCntr = OrderedMap<number, ToolReplacements>;
+export type ToolReplacementsByStation = OrderedMap<StationGroupAndNum, ToolReplacementsByCntr>;
+export declare const last30ToolReplacements: import("jotai").Atom<ToolReplacementsByStation>;
+export declare const specificMonthToolReplacements: import("jotai").Atom<ToolReplacementsByStation>;
+export declare const setLast30ToolReplacements: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};
+export declare const updateLastToolReplacements: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};
+export declare const setSpecificMonthToolReplacements: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};

package/dist/cell-status/tool-replacements.js

@@ -0,0 +1,155 @@
+/* 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 { addDays } from "date-fns";
+import { LogType } from "../network/api.js";
+import { LazySeq, HashMap, OrderedMap, hashValues } from "@seedtactics/immutable-collections";
+import { durationToMinutes } from "../util/parseISODuration.js";
+import { atom } from "jotai";
+export class StationGroupAndNum {
+    constructor(group, num) {
+        this.group = group;
+        this.num = num;
+    }
+    static ofLogCycle(e) {
+        return new StationGroupAndNum(e.loc, e.locnum);
+    }
+    hash() {
+        return hashValues(this.group, this.num);
+    }
+    compare(other) {
+        return this.group === other.group ? this.num - other.num : this.group.localeCompare(other.group);
+    }
+    toString() {
+        return this.group + " #" + this.num.toString();
+    }
+}
+const emptyReplacementsAndUse = {
+    replacements: OrderedMap.empty(),
+    recentUse: HashMap.empty(),
+};
+const last30ToolReplacementsRW = atom(emptyReplacementsAndUse);
+export const last30ToolReplacements = atom((get) => get(last30ToolReplacementsRW).replacements);
+const specificMonthToolReplacementsRW = atom(emptyReplacementsAndUse);
+export const specificMonthToolReplacements = atom((get) => get(specificMonthToolReplacementsRW).replacements);
+function addReplacementsFromLog(old, e) {
+    const key = StationGroupAndNum.ofLogCycle(e);
+    const newReplacements = old.replacements.alter(key, (cycles) => {
+        const replacements = [];
+        for (const use of e.tooluse ?? []) {
+            // see server/lib/BlackMaple.MachineFramework/backend/ToolSnapshotDiff.cs for the original calculations
+            const useDuring = use.toolUseDuringCycle !== null && use.toolUseDuringCycle !== undefined
+                ? durationToMinutes(use.toolUseDuringCycle)
+                : null;
+            const totalUseAtEnd = use.totalToolUseAtEndOfCycle !== null && use.totalToolUseAtEndOfCycle !== undefined
+                ? durationToMinutes(use.totalToolUseAtEndOfCycle)
+                : null;
+            const cntDuring = use.toolUseCountDuringCycle ?? null;
+            const totalCntAtEnd = use.totalToolUseCountAtEndOfCycle ?? null;
+            if ((useDuring || cntDuring) && useDuring === totalUseAtEnd && cntDuring === totalCntAtEnd) {
+                // replace before cycle start
+                const last = old.recentUse.get(key)?.find((e) => e.tool === use.tool && e.pocket === use.pocket);
+                if (last) {
+                    const lastTotalUse = last.totalToolUseAtEndOfCycle
+                        ? durationToMinutes(last.totalToolUseAtEndOfCycle)
+                        : null;
+                    if (lastTotalUse || last.totalToolUseCountAtEndOfCycle) {
+                        replacements.push({
+                            tool: use.tool,
+                            pocket: use.pocket,
+                            type: "ReplaceBeforeCycleStart",
+                            useAtReplacement: lastTotalUse,
+                            cntAtReplacement: last.totalToolUseCountAtEndOfCycle ?? null,
+                        });
+                    }
+                }
+            }
+            else if (use.toolChangeOccurred &&
+                ((useDuring && use.configuredToolLife) || (cntDuring && use.configuredToolLifeCount))) {
+                // replace in the middle of the cycle
+                // the server calculates  useDuring = lifetime - useAtStartOfCycle + useAtEndOfCycle
+                // so solving for useAtStart = lifetime - useDuring + useAtEndOfCycle
+                const lifetime = use.configuredToolLife !== null && use.configuredToolLife !== undefined
+                    ? durationToMinutes(use.configuredToolLife)
+                    : null;
+                const lifeCnt = use.configuredToolLifeCount ?? null;
+                replacements.push({
+                    tool: use.tool,
+                    pocket: use.pocket,
+                    type: "ReplaceInCycle",
+                    totalUseAtBeginningOfCycle: lifetime !== null && useDuring !== null ? lifetime - useDuring + (totalUseAtEnd ?? 0) : null,
+                    totalUseAtEndOfCycle: totalUseAtEnd,
+                    totalCntAtBeginningOfCycle: lifeCnt !== null && cntDuring !== null ? lifeCnt - cntDuring + (totalCntAtEnd ?? 0) : null,
+                    totalCntAtEndOfCycle: totalCntAtEnd,
+                });
+            }
+        }
+        if (replacements.length > 0) {
+            return (cycles ?? OrderedMap.empty()).set(e.counter, { time: e.endUTC, replacements });
+        }
+        else {
+            return cycles;
+        }
+    });
+    const newRecent = e.tooluse ? old.recentUse.set(key, e.tooluse) : old.recentUse;
+    return { replacements: newReplacements, recentUse: newRecent };
+}
+export const setLast30ToolReplacements = atom(null, (_, set, log) => {
+    set(last30ToolReplacementsRW, (oldCycles) => LazySeq.of(log)
+        .filter((e) => e.type === LogType.MachineCycle && !e.startofcycle && !!e.tooluse && e.tooluse.length > 0)
+        .fold(oldCycles, addReplacementsFromLog));
+});
+export const updateLastToolReplacements = atom(null, (_, set, { evt, now, expire }) => {
+    if (evt.logEntry &&
+        !evt.logEntry.startofcycle &&
+        evt.logEntry.type === LogType.MachineCycle &&
+        evt.logEntry.tooluse &&
+        evt.logEntry.tooluse.length > 0) {
+        const log = evt.logEntry;
+        set(last30ToolReplacementsRW, (oldCycles) => {
+            if (expire) {
+                const thirtyDaysAgo = addDays(now, -30);
+                const newReplace = oldCycles.replacements.collectValues((es) => {
+                    const newEs = es.filter((e) => e.time >= thirtyDaysAgo);
+                    return newEs.size > 0 ? newEs : null;
+                });
+                oldCycles = { replacements: newReplace, recentUse: oldCycles.recentUse };
+            }
+            return addReplacementsFromLog(oldCycles, log);
+        });
+    }
+});
+export const setSpecificMonthToolReplacements = atom(null, (_, set, log) => {
+    set(specificMonthToolReplacementsRW, LazySeq.of(log)
+        .filter((e) => e.type === LogType.MachineCycle && !e.startofcycle && !!e.tooluse && e.tooluse.length > 0)
+        .fold(emptyReplacementsAndUse, addReplacementsFromLog));
+});

package/dist/cell-status/tool-usage.d.ts

@@ -0,0 +1,25 @@
+import { ILogEntry } from "../network/api.js";
+import type { ServerEventAndTime } from "./loading.js";
+import { PartAndStationOperation } from "./estimated-cycle-times.js";
+import { HashMap, OrderedSet } from "@seedtactics/immutable-collections";
+import { Atom } from "jotai";
+export type ProgramToolUseInSingleCycle = {
+    readonly tools: ReadonlyArray<{
+        readonly toolName: string;
+        readonly cycleUsageMinutes: number;
+        readonly cycleUsageCnt: number;
+        readonly toolChangedDuringMiddleOfCycle: boolean;
+    }>;
+};
+export type RecentProgramToolUse = {
+    readonly machines: OrderedSet<string>;
+    readonly recentCycles: ReadonlyArray<ProgramToolUseInSingleCycle>;
+};
+export type ToolUsage = HashMap<PartAndStationOperation, RecentProgramToolUse>;
+export declare const last30ToolUse: Atom<ToolUsage>;
+export declare const setLast30ToolUse: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};
+export declare const updateLast30ToolUse: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};

package/dist/cell-status/tool-usage.js

@@ -0,0 +1,95 @@
+/* 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 { durationToMinutes } from "../util/parseISODuration.js";
+import { isOutlier, last30EstimatedCycleTimes, PartAndStationOperation, } from "./estimated-cycle-times.js";
+import { LazySeq, HashMap, OrderedSet } from "@seedtactics/immutable-collections";
+import { atom } from "jotai";
+import { stat_name_and_num } from "./station-cycles.js";
+const last30ToolUseRW = atom(HashMap.empty());
+export const last30ToolUse = last30ToolUseRW;
+function process_tools(cycle, estimatedCycleTimes, toolUsage) {
+    if (cycle.tooluse === undefined || cycle.tooluse.length === 0 || cycle.type !== LogType.MachineCycle) {
+        return toolUsage;
+    }
+    const stats = cycle.material.length > 0
+        ? estimatedCycleTimes.get(PartAndStationOperation.ofLogCycle(cycle))
+        : undefined;
+    const elapsed = durationToMinutes(cycle.elapsed);
+    if (stats === undefined || isOutlier(stats, elapsed)) {
+        return toolUsage;
+    }
+    const key = PartAndStationOperation.ofLogCycle(cycle);
+    const toolsUsedInCycle = LazySeq.of(cycle.tooluse)
+        .groupBy((u) => u.tool)
+        .map(([toolName, uses]) => {
+        const useDuring = LazySeq.of(uses).sumBy((use) => use.toolUseDuringCycle && use.toolUseDuringCycle !== ""
+            ? durationToMinutes(use.toolUseDuringCycle)
+            : 0);
+        const cntDuring = LazySeq.of(uses).sumBy((use) => use.toolUseCountDuringCycle ?? 0);
+        return {
+            toolName,
+            cycleUsageMinutes: useDuring,
+            cycleUsageCnt: cntDuring,
+            toolChangedDuringMiddleOfCycle: LazySeq.of(uses).some((use) => use.toolChangeOccurred ?? false),
+        };
+    })
+        .toRArray();
+    if (toolsUsedInCycle.length === 0 && toolUsage.has(key)) {
+        return toolUsage;
+    }
+    return toolUsage.modify(key, (old) => {
+        if (old) {
+            const n = old.recentCycles.slice(-4);
+            n.push({ tools: toolsUsedInCycle });
+            return { machines: old.machines.add(stat_name_and_num(cycle.loc, cycle.locnum)), recentCycles: n };
+        }
+        else {
+            return {
+                machines: OrderedSet.empty().add(stat_name_and_num(cycle.loc, cycle.locnum)),
+                recentCycles: [{ tools: toolsUsedInCycle }],
+            };
+        }
+    });
+}
+export const setLast30ToolUse = atom(null, (get, set, log) => {
+    const estimated = get(last30EstimatedCycleTimes);
+    set(last30ToolUseRW, (oldUsage) => log.reduce((usage, log) => process_tools(log, estimated, usage), oldUsage));
+});
+export const updateLast30ToolUse = atom(null, (get, set, { evt }) => {
+    if (evt.logEntry) {
+        const log = evt.logEntry;
+        const estimated = get(last30EstimatedCycleTimes);
+        set(last30ToolUseRW, (oldUsage) => process_tools(log, estimated, oldUsage));
+    }
+});

package/dist/components/App.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode, ComponentType } from "react";
+import { ChooseModeItem } from "./ChooseMode.js";
+import * as serverSettings from "../network/server-settings.js";
+export declare function NavTabs({ children }: {
+    children?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export interface AppProps {
+    readonly renderCustomPage?: (custom: ReadonlyArray<string>) => {
+        readonly nav: ComponentType | undefined;
+        readonly page: ReactNode;
+    };
+    readonly chooseModes?: (i: serverSettings.FMSInfoAndUser) => ReadonlyArray<ChooseModeItem> | null;
+}
+declare const App: import("react").NamedExoticComponent<AppProps>;
+export default App;