@nordicsemiconductor/pc-nrfconnect-shared 60.0.0-pre1

package/typings/generated/src/Device/DeviceSelector/SelectDevice.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import './select-device.scss';
+interface Props {
+    deviceListVisible: boolean;
+    toggleDeviceListVisible: () => void;
+}
+declare const _default: ({ deviceListVisible, toggleDeviceListVisible }: Props) => JSX.Element;
+export default _default;

package/typings/generated/src/Device/DeviceSelector/SelectedDevice.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import './selected-device.scss';
+declare const _default: ({ doDeselectDevice, toggleDeviceListVisible, }: {
+    doDeselectDevice: () => void;
+    toggleDeviceListVisible: () => void;
+}) => JSX.Element;
+export default _default;

package/typings/generated/src/Device/DeviceSetup/DeviceSetupView.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const _default: () => JSX.Element;
+export default _default;

package/typings/generated/src/Device/deviceAutoSelectSlice.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import type { RootState } from '../store';
+import type { Device } from './deviceSlice';
+export interface WaitForDevice {
+    timeout: number;
+    when: 'always' | 'applicationMode' | 'dfuBootLoaderMode' | 'sameTraits' | ((device: Device) => boolean);
+    once: boolean;
+    onSuccess?: (device: Device) => void;
+    onFail?: (reason?: string) => void;
+}
+export interface DeviceAutoSelectState {
+    autoReselect: boolean;
+    device?: Device;
+    disconnectionTime?: number;
+    waitForDevice?: WaitForDevice;
+    autoReconnectTimeout?: NodeJS.Timeout;
+    lastArrivedDeviceId?: number;
+    arrivedButWrongWhen?: boolean;
+}
+export declare const reducer: import("redux").Reducer<DeviceAutoSelectState, import("redux").AnyAction>, setWaitForDeviceTimeout: import("@reduxjs/toolkit").ActionCreatorWithPayload<NodeJS.Timeout, "deviceAutoSelect/setWaitForDeviceTimeout">, clearWaitForDeviceTimeout: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"deviceAutoSelect/clearWaitForDeviceTimeout">, setAutoSelectDevice: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<Device | undefined, "deviceAutoSelect/setAutoSelectDevice">, setDisconnectedTime: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number | undefined, "deviceAutoSelect/setDisconnectedTime">, setAutoReselect: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, "deviceAutoSelect/setAutoReselect">, setWaitForDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<WaitForDevice, "deviceAutoSelect/setWaitForDevice">, clearWaitForDevice: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"deviceAutoSelect/clearWaitForDevice">, setLastArrivedDeviceId: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<number | undefined, "deviceAutoSelect/setLastArrivedDeviceId">, setArrivedButWrongWhen: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean | undefined, "deviceAutoSelect/setArrivedButWrongWhen">;
+export declare const getAutoReselectDevice: (state: RootState) => Device | undefined;
+export declare const getAutoReselect: (state: RootState) => boolean;
+export declare const getWaitingToAutoReselect: (state: RootState) => boolean;
+export declare const getWaitingForDeviceTimeout: (state: RootState) => boolean;
+export declare const getDisconnectionTime: (state: RootState) => number | undefined;
+export declare const getWaitForDevice: (state: RootState) => WaitForDevice | undefined;
+export declare const getLastArrivedDeviceId: (state: RootState) => number | undefined;
+export declare const getArrivedButWrongWhen: (state: RootState) => boolean | undefined;

package/typings/generated/src/Device/deviceInfo/deviceInfo.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { Device } from '../deviceSlice';
+interface DeviceInfo {
+    name?: string | null;
+    cores?: number;
+    icon: React.ElementType;
+    website: {
+        productPagePath?: string;
+        buyOnlineParams?: string;
+    };
+}
+export declare const deviceInfo: (device: Device) => DeviceInfo;
+export declare const displayedDeviceName: (device: Device, { respectNickname }?: {
+    respectNickname?: boolean | undefined;
+}) => string;
+export declare const productPageUrl: (device: Device) => string | undefined;
+export declare const buyOnlineUrl: (device: Device) => string | undefined;
+export {};

package/typings/generated/src/Device/deviceLibWrapper.d.ts

@@ -0,0 +1,8 @@
+import { LogEvent, ModuleVersion } from '@nordicsemiconductor/nrf-device-lib-js';
+export declare const getDeviceLibContext: () => bigint;
+export declare const logNrfdlLogs: (evt: LogEvent) => void;
+export declare const forwardLogEventsFromDeviceLib: () => () => void;
+export declare const setVerboseDeviceLibLogging: (verboseLogging: boolean) => void;
+type KnownModule = 'nrfdl' | 'nrfdl-js' | 'jprog' | 'JlinkARM';
+export declare const getModuleVersion: (module: KnownModule, versions?: ModuleVersion[]) => ModuleVersion | undefined;
+export {};

package/typings/generated/src/Device/deviceLibWrapper.test.d.ts

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

package/typings/generated/src/Device/deviceLister.d.ts

@@ -0,0 +1,25 @@
+import { Device as NrfdlDevice, DeviceTraits } from '@nordicsemiconductor/nrf-device-lib-js';
+import type { AppDispatch, RootState } from '../store';
+import { Device } from './deviceSlice';
+/**
+ * Wrap the device form nrf-device-lib to make the Device type consistent
+ *
+ * @param {Device} device The input device from nrf-device-lib
+ * @returns {Device} The updated device
+ */
+export declare const wrapDeviceFromNrfdl: (device: NrfdlDevice) => Device;
+/**
+ * Wrap the device form nrf-device-lib to make the Device type consistent
+ *
+ * @param {Device[]} devices The input devices from nrf-device-lib
+ * @returns {Device[]} The updated devices
+ */
+export declare const wrapDevicesFromNrfdl: (devices: NrfdlDevice[]) => Device[];
+export declare const hasValidDeviceTraits: (deviceTraits: DeviceTraits, requiredTraits: DeviceTraits) => boolean;
+export declare const startWatchingDevices: (deviceListing: DeviceTraits, onDeviceConnected: (device: Device) => void, onDeviceDisconnected: (device: Device) => void, onDeviceDeselected: () => void, doSelectDevice: (device: Device, autoReselected: boolean) => void) => (dispatch: AppDispatch, getState: () => RootState) => Promise<void>;
+/**
+ * Stops watching for devices.
+ *
+ * @returns {undefined}
+ */
+export declare const stopWatchingDevices: () => void;

package/typings/generated/src/Device/deviceLister.test.d.ts

@@ -0,0 +1,2 @@
+declare const _default: null;
+export default _default;

package/typings/generated/src/Device/deviceSetup.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import { AppDispatch, RootState } from '../store';
+import { Device } from './deviceSlice';
+import { InitPacket } from './initPacket';
+export interface DfuEntry {
+    key: string;
+    description?: string;
+    application: string;
+    semver: string;
+    softdevice?: string | Buffer;
+    params: Partial<InitPacket>;
+}
+export interface JprogEntry {
+    key: string;
+    description?: string;
+    fw: string;
+    fwIdAddress: number;
+    fwVersion: string;
+}
+export interface DeviceSetup {
+    supportsProgrammingMode: (device: Device) => boolean;
+    getFirmwareOptions: (device: Device) => {
+        key: string;
+        description?: string;
+        programDevice: (onProgress: (progress: number, message?: string) => void) => (dispatch: AppDispatch, getState: () => RootState) => Promise<Device>;
+    }[];
+    isExpectedFirmware: (device: Device) => (dispatch: AppDispatch, getState: () => RootState) => Promise<{
+        device: Device;
+        validFirmware: boolean;
+    }>;
+    tryToSwitchToApplicationMode: (device: Device) => (dispatch: AppDispatch, getState: () => RootState) => Promise<Device | null>;
+}
+export interface DeviceSetupConfig {
+    deviceSetups: DeviceSetup[];
+    allowCustomDevice?: boolean;
+    confirmMessage?: string;
+    choiceMessage?: string;
+}
+export declare const prepareDevice: (device: Device, deviceSetupConfig: DeviceSetupConfig, onSuccess: (device: Device) => void, onFail: (reason?: unknown) => void, checkCurrentFirmwareVersion?: boolean, requireUserConfirmation?: boolean) => (dispatch: AppDispatch) => Promise<void>;
+export declare const setupDevice: (device: Device, deviceSetupConfig: DeviceSetupConfig, onDeviceIsReady: (device: Device) => void, doDeselectDevice: () => void) => (dispatch: AppDispatch, getState: () => RootState) => Promise<void>;

package/typings/generated/src/Device/deviceSetupSlice.d.ts

@@ -0,0 +1,20 @@
+import type { RootState } from '../store';
+export interface DeviceSetupState {
+    visible: boolean;
+    onUserInput?: (canceled: boolean, choice?: number) => void;
+    message: string;
+    progressMessage?: string;
+    choices?: string[];
+    progress?: number;
+}
+export declare const reducer: import("redux").Reducer<DeviceSetupState, import("redux").AnyAction>, openDeviceSetupDialog: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    onUserInput?: ((canceled: boolean, choice?: number) => void) | undefined;
+    message: string;
+    choices?: string[] | undefined;
+}, "deviceSetup/openDeviceSetupDialog">, closeDeviceSetupDialog: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"deviceSetup/closeDeviceSetupDialog">, setDeviceSetupProgress: import("@reduxjs/toolkit").ActionCreatorWithPayload<number, "deviceSetup/setDeviceSetupProgress">, setDeviceSetupMessage: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "deviceSetup/setDeviceSetupMessage">, setDeviceSetupProgressMessage: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "deviceSetup/setDeviceSetupProgressMessage">, deviceSetupUserInputReceived: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"deviceSetup/deviceSetupUserInputReceived">;
+export declare const isDeviceSetupDialogVisible: (state: RootState) => boolean;
+export declare const getDeviceSetupProgress: (state: RootState) => number | undefined;
+export declare const getDeviceSetupMessage: (state: RootState) => string;
+export declare const getDeviceSetupProgressMessage: (state: RootState) => string | undefined;
+export declare const getDeviceSetupChoices: (state: RootState) => string[] | undefined;
+export declare const getDeviceSetupUserInputCallback: (state: RootState) => ((canceled: boolean, choice?: number) => void) | undefined;

package/typings/generated/src/Device/deviceSlice.d.ts

@@ -0,0 +1,30 @@
+import type { Device as NrfdlDevice, SerialPort } from '@nordicsemiconductor/nrf-device-lib-js';
+import type { AutoDetectTypes } from '@serialport/bindings-cpp';
+import { SerialPortOpenOptions } from 'serialport';
+import type { RootState } from '../store';
+export interface Device extends NrfdlDevice {
+    serialNumber: string;
+    boardVersion?: string;
+    nickname?: string;
+    serialport?: SerialPort;
+    favorite?: boolean;
+    id: number;
+    persistedSerialPortOptions?: SerialPortOpenOptions<AutoDetectTypes>;
+}
+export interface DeviceState {
+    devices: Map<string, Device>;
+    deviceInfo: Device | null;
+    selectedSerialNumber: string | null;
+    readbackProtection: 'unknown' | 'protected' | 'unprotected';
+}
+export declare const reducer: import("redux").Reducer<DeviceState, import("redux").AnyAction>, deselectDevice: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"device/deselectDevice">, resetDeviceNickname: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "device/resetDeviceNickname">, selectDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<Device, "device/selectDevice">, addDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<Device, "device/addDevice">, removeDevice: import("@reduxjs/toolkit").ActionCreatorWithPayload<Device, "device/removeDevice">, setDevices: import("@reduxjs/toolkit").ActionCreatorWithPayload<Device[], "device/setDevices">, setDeviceNickname: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[serialNumber: string, nickname: string], {
+    serialNumber: string;
+    nickname: string;
+}, "device/setDeviceNickname", never, never>, toggleDeviceFavorited: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "device/toggleDeviceFavorited">, setReadbackProtected: import("@reduxjs/toolkit").ActionCreatorWithPayload<"unknown" | "protected" | "unprotected", "device/setReadbackProtected">, persistSerialPortOptions: import("@reduxjs/toolkit").ActionCreatorWithPayload<SerialPortOpenOptions<AutoDetectTypes>, "device/persistSerialPortOptions">;
+export declare const getDevice: (serialNumber: string) => (state: RootState) => Device | undefined;
+export declare const getDevices: (state: RootState) => Map<string, Device>;
+export declare const deviceIsSelected: (state: RootState) => boolean;
+export declare const selectedDevice: (state: RootState) => Device | undefined;
+export declare const deviceInfo: (state: RootState) => Device | null;
+export declare const selectedSerialNumber: (state: RootState) => string | null;
+export declare const getReadbackProtection: (state: RootState) => "unknown" | "protected" | "unprotected";

package/typings/generated/src/Device/dfu-cc.d.ts

@@ -0,0 +1,3 @@
+import * as $protobuf from 'protobufjs/light';
+declare const $root: $protobuf.Namespace;
+export default $root;

package/typings/generated/src/Device/initPacket.d.ts

@@ -0,0 +1,109 @@
+/// <reference types="node" />
+import protobuf from 'protobufjs';
+export declare enum FwType {
+    APPLICATION = 0,
+    SOFTDEVICE = 1,
+    BOOTLOADER = 2,
+    SOFTDEVICE_BOOTLOADER = 3
+}
+export declare enum HashType {
+    NO_HASH = 0,
+    CRC = 1,
+    SHA128 = 2,
+    SHA256 = 3,
+    SHA512 = 4
+}
+export declare const OpCode: {
+    RESET: number;
+    INIT: number;
+};
+export declare const SignatureType: {
+    ECDSA_P256_SHA256: number;
+    ED25519: number;
+};
+export interface InitPacket {
+    fwVersion?: number;
+    hwVersion?: number;
+    sdReq?: number[];
+    fwType?: number;
+    sdSize: number;
+    blSize: number;
+    appSize: number;
+    hashType: number;
+    hash?: Buffer;
+    isDebug: boolean;
+    signatureType?: number;
+    signature?: [];
+}
+export declare const defaultInitPacket: InitPacket;
+export interface DfuImage {
+    name: string;
+    initPacket: InitPacket;
+    firmwareImage: Buffer;
+}
+/**
+ * Create reset command packet
+ *
+ * @param {Integer} timeout         the timeout for reset
+ * @param {Integer} signatureType   the type of signature
+ * @param {Array}   signature       the signature in bytes
+ *
+ * @returns {protobuf.Message | undefined} reset command packet
+ */
+export declare const createResetPacket: (timeout: number, signatureType: number, signature: []) => protobuf.Message;
+/**
+ * Create reset command buffer
+ *
+ * @param {Integer} timeout         the timeout for reset
+ * @param {Integer} signatureType   the type of signature
+ * @param {Array}   signature       the signature in bytes
+ *
+ * @returns {Uint8Array} converted from reset command packet
+ */
+export declare const createResetPacketBuffer: (timeout: number, signatureType: number, signature: []) => Uint8Array;
+/**
+ * Create init command packet
+ *
+ * @param {Integer}         fwVersion       the firmware version
+ * @param {Integer}         hwVersion       the hardware version
+ * @param {Array}           sdReq           the softdevice requirements
+ * @param {FwType}          fwType          the firmware type
+ * @param {Integer}         sdSize          the size of softDevice
+ * @param {Integer}         blSize          the size of bootloader
+ * @param {Integer}         appSize         the size of application
+ * @param {HashType}        hashType        the type of hash
+ * @param {Array}           hash            the hash in bytes
+ * @param {Boolean}         isDebug         whether it is in debug mode or not
+ * @param {SignatureType}   signatureType   the type of signature
+ * @param {Array}           signature       the signature in bytes
+ *
+ * @returns {protobuf.Message} init command packet
+ */
+export declare const createInitPacket: (fwVersion: number | undefined, hwVersion: number | undefined, sdReq: number[] | undefined, fwType: number | undefined, sdSize: number | undefined, blSize: number | undefined, appSize: number | undefined, hashType: number | undefined, hash: Buffer | undefined, isDebug: boolean, signatureType: number | undefined, signature: [] | undefined) => protobuf.Message;
+/**
+ * Create init command buffer
+ *
+ * @param {Integer}         fwVersion       the firmware version
+ * @param {Integer}         hwVersion       the hardware version
+ * @param {Array}           sdReq           the softdevice requirements
+ * @param {FwType}          fwType          the firmware type
+ * @param {Integer}         sdSize          the size of softdevice
+ * @param {Integer}         blSize          the size of bootloader
+ * @param {Integer}         appSize         the size of application
+ * @param {HashType}        hashType        the type of hash
+ * @param {Array}           hash            the hash in bytes
+ * @param {Boolean}         isDebug         whether it is in debug mode or not
+ * @param {SignatureType}   signatureType   the type of signature
+ * @param {Array}           signature       the signature in bytes
+ *
+ * @returns {Uint8Array} converted from init command packet
+ */
+export declare const createInitPacketBuffer: (fwVersion: number, hwVersion: number, sdReq: number[], fwType: number, sdSize: number, blSize: number, appSize: number, hashType: number, hash: Buffer, isDebug: boolean, signatureType: number, signature: []) => Buffer;
+/**
+ * Create init command packet Uint8Array
+ *
+ * @param {InitPacket} packetParams the InitPacket which carries all information
+ *
+ * @returns {Uint8Array} converted from init command packet buffer
+ */
+export declare const createInitPacketUint8Array: (packetParams: InitPacket) => Uint8Array;

package/typings/generated/src/Device/jprogOperations.d.ts

@@ -0,0 +1,2 @@
+import { DeviceSetup, JprogEntry } from './deviceSetup';
+export declare const jprogDeviceSetup: (firmware: JprogEntry[], needSerialport?: boolean) => DeviceSetup;

package/typings/generated/src/Device/sdfuOperations.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { AppDispatch } from '../store';
+import { DeviceSetup, DfuEntry } from './deviceSetup';
+import { Device } from './deviceSlice';
+import { DfuImage } from './initPacket';
+export declare const isDeviceInDFUBootloader: (device: Device) => boolean;
+export declare const ensureBootloaderMode: (device: Device) => boolean;
+export declare const switchToBootloaderMode: (device: Device, onSuccess: (device: Device) => void, onFail: (reason?: unknown) => void) => (dispatch: AppDispatch) => void;
+export declare const switchToApplicationMode: (device: Device, onSuccess: (device: Device) => void, onFail: (reason?: unknown) => void) => (dispatch: AppDispatch) => void;
+export declare const sdfuDeviceSetup: (dfuFirmware: DfuEntry[], needSerialport?: boolean) => DeviceSetup;
+declare const _default: {
+    createDfuZipBuffer: (dfuImages: DfuImage[]) => Promise<Buffer>;
+};
+export default _default;

package/typings/generated/src/Dialog/Dialog.d.ts

@@ -0,0 +1,64 @@
+import { ReactNode } from 'react';
+import { ButtonVariants } from '../Button/Button';
+import './dialog.scss';
+type CoreProps = {
+    isVisible: boolean;
+    onHide?: () => void;
+    className?: string;
+    size?: 'sm' | 'm' | 'lg' | 'xl';
+    children: ReactNode;
+};
+type DialogProps = CoreProps & {
+    closeOnUnfocus?: boolean;
+    closeOnEsc?: boolean;
+};
+export declare const Dialog: {
+    ({ isVisible, closeOnUnfocus, closeOnEsc, onHide, className, size, children, }: DialogProps): JSX.Element;
+    Header({ title, headerIcon, showSpinner, }: {
+        title: string;
+        headerIcon?: string | undefined;
+        showSpinner?: boolean | undefined;
+    }): JSX.Element;
+    Body({ children }: {
+        children: ReactNode;
+    }): JSX.Element;
+    Footer({ children }: {
+        children: ReactNode;
+    }): JSX.Element;
+};
+export interface DialogButtonProps {
+    onClick: () => void;
+    variant?: ButtonVariants;
+    className?: string;
+    disabled?: boolean;
+    children: ReactNode;
+}
+export declare const DialogButton: ({ variant, onClick, className, disabled, children, }: DialogButtonProps) => JSX.Element;
+interface GenericDialogProps extends CoreProps {
+    title: string;
+    footer: ReactNode;
+    headerIcon?: string;
+    showSpinner?: boolean;
+    closeOnUnfocus?: boolean;
+    closeOnEsc?: boolean;
+}
+export declare const GenericDialog: ({ isVisible, onHide, title, headerIcon, children, className, footer, showSpinner, closeOnUnfocus, closeOnEsc, size, }: GenericDialogProps) => JSX.Element;
+interface InfoProps extends CoreProps {
+    title?: string;
+    headerIcon?: string;
+    onHide: () => void;
+}
+export declare const InfoDialog: ({ isVisible, title, headerIcon, children, onHide, size, className, }: InfoProps) => JSX.Element;
+export declare const ErrorDialog: (props: Omit<InfoProps, 'headerIcon'>) => JSX.Element;
+interface ConfirmationDialogProps extends Omit<CoreProps, 'onHide'> {
+    title?: string;
+    headerIcon?: string;
+    confirmLabel?: string;
+    onConfirm: () => void;
+    cancelLabel?: string;
+    onCancel: () => void;
+    optionalLabel?: string;
+    onOptional?: () => void;
+}
+export declare const ConfirmationDialog: ({ isVisible, title, headerIcon, children, className, confirmLabel, onConfirm, cancelLabel, onCancel, optionalLabel, onOptional, size, }: ConfirmationDialogProps) => JSX.Element;
+export {};

package/typings/generated/src/Dialog/Dialog.test.d.ts

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

package/typings/generated/src/Dropdown/Dropdown.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+export interface DropdownItem {
+    label: React.ReactNode;
+    value: string;
+}
+export interface DropdownProps {
+    id?: string;
+    label?: React.ReactNode;
+    items: DropdownItem[];
+    onSelect: (item: DropdownItem) => void;
+    disabled?: boolean;
+    selectedItem: DropdownItem;
+    numItemsBeforeScroll?: number;
+}
+declare const _default: ({ id, label, items, onSelect, disabled, selectedItem, numItemsBeforeScroll, }: DropdownProps) => JSX.Element;
+export default _default;

package/typings/generated/src/Dropdown/Dropdown.test.d.ts

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

package/typings/generated/src/ErrorBoundary/ErrorBoundary.d.ts

@@ -0,0 +1,26 @@
+import React, { ReactNode } from 'react';
+import { Device } from '../Device/deviceSlice';
+import './error-boundary.scss';
+interface Props {
+    children: ReactNode;
+    selectedSerialNumber?: string;
+    selectedDevice?: Device;
+    devices?: Device[];
+    appName?: string;
+    restoreDefaults?: () => void;
+    sendUsageData?: (message: string) => void;
+}
+declare class ErrorBoundary extends React.Component<Props, {
+    hasError: boolean;
+    error: Error | null;
+    systemReport: string | null;
+}> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): {
+        hasError: boolean;
+        error: Error;
+    };
+    componentDidCatch(error: Error): void;
+    render(): React.ReactNode;
+}
+export default ErrorBoundary;

package/typings/generated/src/ErrorBoundary/ErrorBoundary.test.d.ts

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

package/typings/generated/src/ErrorDialog/ErrorDialog.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import './error.scss';
+declare const ErrorDialog: () => JSX.Element;
+export default ErrorDialog;

package/typings/generated/src/ErrorDialog/ErrorDialog.test.d.ts

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

package/typings/generated/src/ErrorDialog/errorDialogSlice.d.ts

@@ -0,0 +1,23 @@
+import type { RootState } from '../store';
+export interface ErrorResolutions {
+    [key: string]: () => void;
+}
+export interface ErrorMessage {
+    message: string;
+    detail?: string;
+}
+export interface ErrorDialog {
+    isVisible: boolean;
+    messages: ErrorMessage[];
+    errorResolutions?: ErrorResolutions;
+}
+export declare const reducer: import("redux").Reducer<ErrorDialog, import("redux").AnyAction>, hideDialog: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"errorDialog/hideDialog">, showDialog: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[message: string, errorResolutions?: ErrorResolutions | undefined, detail?: string | undefined], {
+    message: {
+        message: string;
+        detail: string | undefined;
+    };
+    errorResolutions: ErrorResolutions | undefined;
+}, "errorDialog/showDialog", never, never>;
+export declare const isVisible: (state: RootState) => boolean;
+export declare const messages: (state: RootState) => ErrorMessage[];
+export declare const errorResolutions: (state: RootState) => ErrorResolutions | undefined;

package/typings/generated/src/ErrorDialog/errorDialogSlice.test.d.ts

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

package/typings/generated/src/FactoryReset/FactoryResetButton.d.ts

@@ -0,0 +1,12 @@
+import { FC } from 'react';
+import { ButtonVariants } from '../Button/Button';
+interface Props {
+    resetFn?: () => void;
+    label: string;
+    modalText?: string;
+    variant?: ButtonVariants;
+    classNames?: string;
+    large?: boolean;
+}
+declare const FactoryResetButton: FC<Props>;
+export default FactoryResetButton;

package/typings/generated/src/FactoryReset/FactoryResetButton.test.d.ts

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

package/typings/generated/src/InlineInput/InlineInput.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import './inline-input.scss';
+interface Props {
+    disabled?: boolean;
+    value: string;
+    isValid?: (value: string) => boolean;
+    onChange: (value: string) => void;
+    onChangeComplete?: (value: string) => void;
+    onKeyboardIncrementAction?: () => string;
+    onKeyboardDecrementAction?: () => string;
+    className?: string;
+}
+declare const InlineInput: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLInputElement>>;
+export default InlineInput;

package/typings/generated/src/InlineInput/NumberInlineInput.d.ts

@@ -0,0 +1,12 @@
+import { FC } from 'react';
+import { RangeOrValues } from '../Slider/range';
+import './number-inline-input.scss';
+export interface Props {
+    disabled?: boolean;
+    value: number;
+    range: RangeOrValues;
+    onChange: (value: number) => void;
+    onChangeComplete?: (value: number) => void;
+}
+declare const NumberInlineInput: FC<Props>;
+export default NumberInlineInput;

package/typings/generated/src/Log/LogEntry.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { LogEntry } from 'winston';
+import './log-entry.scss';
+declare const _default: ({ entry }: {
+    entry: LogEntry;
+}) => JSX.Element;
+export default _default;

package/typings/generated/src/Log/LogViewer.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import './log-viewer.scss';
+export declare const useInitialisedLog: () => void;
+declare const _default: () => JSX.Element;
+export default _default;

package/typings/generated/src/Log/logSlice.d.ts

@@ -0,0 +1,12 @@
+import { LogEntry } from 'winston';
+import type { RootState } from '../store';
+export interface Log {
+    autoScroll: boolean;
+    logEntries: LogEntry[];
+    isLoggingVerbose: boolean;
+}
+export declare const autoScroll: (state: RootState) => boolean;
+export declare const logEntries: (state: RootState) => LogEntry[];
+export declare const isLoggingVerbose: () => boolean;
+export declare const isLoggingVerboseSelector: (state: RootState) => boolean;
+export declare const reducer: import("redux").Reducer<Log, import("redux").AnyAction>, addEntries: import("@reduxjs/toolkit").ActionCreatorWithPayload<LogEntry[], "log/addEntries">, clear: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"log/clear">, toggleAutoScroll: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"log/toggleAutoScroll">, toggleIsLoggingVerbose: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"log/toggleIsLoggingVerbose">;

package/typings/generated/src/Log/syncLogToStore.d.ts

@@ -0,0 +1,11 @@
+import { AppDispatch } from '../store';
+/**
+ * Starts syncing to new log entries from the application's log buffer.
+ * Incoming entries are added to the state, so that they can be displayed
+ * in the UI.
+ *
+ * @param {function} dispatch The redux dispatch function.
+ * @returns {function(*)} Function that stops the listener.
+ */
+declare const _default: (dispatch: AppDispatch) => () => void;
+export default _default;

package/typings/generated/src/Logo/Logo.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import './logo.scss';
+declare const Logo: FC<{
+    changeWithDeviceState?: boolean;
+}>;
+export default Logo;

package/typings/generated/src/Main/Main.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import './main.scss';
+declare const _default: ({ children }: {
+    children?: ReactNode;
+}) => JSX.Element;
+export default _default;

package/typings/generated/src/MasonryLayout/MasonryLayout.d.ts

@@ -0,0 +1,14 @@
+import { PropsWithChildren } from 'react';
+interface MasonryLayoutProperties {
+    minWidth: number;
+    className?: string;
+}
+/**
+ * Builds a masonry layout around all depth 1 child components.
+ * Note: only depth 1 children are considered for the layout.
+ * This also applies for React.Fragment wrapped components.
+ * @param {number} minWidth minimum width of every item in this layout.
+ * @returns {React.FC<MasonryLayoutProperties>} React Component.
+ */
+declare const _default: ({ children, minWidth, className, }: PropsWithChildren<MasonryLayoutProperties>) => JSX.Element;
+export default _default;

package/typings/generated/src/NavBar/NavBar.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import './nav-bar.scss';
+declare const _default: ({ deviceSelect }: {
+    deviceSelect?: ReactNode;
+}) => JSX.Element;
+export default _default;

package/typings/generated/src/NavBar/NavMenu.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const NavMenu: () => JSX.Element;
+export default NavMenu;

package/typings/generated/src/NavBar/NavMenu.test.d.ts

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