@nordicsemiconductor/pc-nrfconnect-shared 120.0.0 → 122.0.0

package/src/Device/jprogOperations.ts

@@ -5,6 +5,7 @@
  */
 
 import NrfutilDeviceLib from '../../nrfutil/device/device';
+import { DeviceInfo } from '../../nrfutil/device/deviceInfo';
 import { FWInfo } from '../../nrfutil/device/getFwInfo';
 import logger from '../logging';
 import type { AppThunk, RootState } from '../store';
@@ -18,14 +19,15 @@ const getDeviceReadProtection = async (
     readbackProtection: 'unknown' | 'protected' | 'unprotected';
 }> => {
     try {
+        logger.info('Checking readback protection on device');
         const info = await NrfutilDeviceLib.getFwInfo(device);
         return {
             fwInfo: info,
             readbackProtection: 'unprotected',
         };
-    } catch (error) {
-        // @ts-expect-error Wrongly typed in device lib at the moment
-        if (error.error_code === 24) {
+    } catch (e) {
+        const error = e as Error;
+        if (error.message.includes('NotAvailableBecauseProtection')) {
             logger.warn(
                 'Readback protection on device enabled. Unable to verify that the firmware version is correct.'
             );
@@ -49,29 +51,50 @@ const programDeviceWithFw =
     ): AppThunk<RootState, Promise<Device>> =>
     async (dispatch, getState) => {
         try {
-            if (getState().device.readbackProtection === 'protected') {
-                logger.info('Recovering device');
-                onProgress(0, 'Recovering device');
-                await NrfutilDeviceLib.recover(device, 'Application');
+            const batch = NrfutilDeviceLib.batch();
+            if (getState().device.readbackProtection !== 'unprotected') {
+                batch.recover('Application', {
+                    onTaskBegin: () =>
+                        logger.info(`Device protected, recovering device`),
+                    onTaskEnd: () => logger.info(`Finished recovering device.`),
+                    onException: () =>
+                        logger.error(`Failed to recover device.`),
+                    onProgress: progress => {
+                        onProgress(
+                            progress.totalProgressPercentage,
+                            'Recovering device'
+                        );
+                    },
+                });
             }
 
-            logger.debug(
-                `Programming ${device.serialNumber} with ${selectedFw.fw}`
-            );
-            await NrfutilDeviceLib.program(
-                device,
-                selectedFw.fw,
-                progress => {
+            batch.program(selectedFw.fw, 'Application', undefined, undefined, {
+                onTaskBegin: () => logger.info(`Programming device`),
+                onTaskEnd: () => logger.info(`Finished programming device.`),
+                onException: () => logger.error(`Failed to program device.`),
+                onProgress: progress => {
                     onProgress(
                         progress.totalProgressPercentage,
                         progress.message ?? 'programming'
                     );
                 },
-                'Application'
-            );
-            logger.debug(`Resetting ${device.serialNumber}`);
-            onProgress(100, 'Resetting device');
+            });
+
+            batch.reset('Application', undefined, {
+                onTaskBegin: () => logger.info(`Resting device`),
+                onTaskEnd: () => logger.info(`Finished resting device.`),
+                onException: () => logger.error(`Failed to reset device.`),
+                onProgress: progress => {
+                    onProgress(
+                        progress.totalProgressPercentage,
+                        'Resetting device'
+                    );
+                },
+            });
+
+            await batch.run(device);
             await NrfutilDeviceLib.reset(device);
+            onProgress(0, 'Updating readback protection');
             const { readbackProtection } = await getDeviceReadProtection(
                 device
             );
@@ -88,12 +111,18 @@ const programDeviceWithFw =
         return device;
     };
 
-const firmwareOptions = (device: Device, firmware: JprogEntry[]) =>
+const firmwareOptions = (
+    device: Device,
+    firmware: JprogEntry[],
+    deviceInfo?: DeviceInfo
+) =>
     firmware.filter(fw => {
-        const family = (device.jlink?.deviceFamily || '').toLowerCase();
-        const deviceType = (device.jlink?.deviceVersion || '').toLowerCase();
+        const family = (device.devkit?.deviceFamily || '').toLowerCase();
+        const deviceType = (
+            deviceInfo?.jlink?.deviceVersion || ''
+        ).toLowerCase();
         const shortDeviceType = deviceType.split('_').shift();
-        const boardVersion = (device.jlink?.boardVersion || '').toLowerCase();
+        const boardVersion = (device.devkit?.boardVersion || '').toLowerCase();
 
         const key = fw.key.toLowerCase();
         return (
@@ -108,11 +137,11 @@ export const jprogDeviceSetup = (
     firmware: JprogEntry[],
     needSerialport = false
 ): DeviceSetup => ({
-    supportsProgrammingMode: (device: Device) =>
+    supportsProgrammingMode: device =>
         (needSerialport === !!device.traits.serialPorts || !needSerialport) &&
         !!device.traits.jlink,
-    getFirmwareOptions: device =>
-        firmwareOptions(device, firmware).map(firmwareOption => ({
+    getFirmwareOptions: (device, deviceInfo) =>
+        firmwareOptions(device, firmware, deviceInfo).map(firmwareOption => ({
             key: firmwareOption.key,
             description: firmwareOption.description,
             programDevice: onProgress => dispatch =>
@@ -120,8 +149,8 @@ export const jprogDeviceSetup = (
                     programDeviceWithFw(device, firmwareOption, onProgress)
                 ),
         })),
-    isExpectedFirmware: (device: Device) => dispatch => {
-        const fwVersions = firmwareOptions(device, firmware);
+    isExpectedFirmware: (device, deviceInfo) => dispatch => {
+        const fwVersions = firmwareOptions(device, firmware, deviceInfo);
         if (fwVersions.length === 0) {
             return Promise.resolve({
                 device,

package/src/Device/sdfuOperations.ts

@@ -46,8 +46,9 @@ export const isDeviceInDFUBootloader = (device: Device) => {
             d.idProduct === NORDIC_DFU_PRODUCT_ID
         );
     }
-    if (device.serialport) {
-        const { vendorId, productId } = device.serialport;
+
+    if (device.serialPorts && device.serialPorts[0]) {
+        const { vendorId, productId } = device.serialPorts[0];
         return vendorId === '1915' && productId?.toUpperCase() === '521F';
     }
     return false;
@@ -410,9 +411,7 @@ const programInDFUBootloader =
         onFail: (reason?: unknown) => void
     ): AppThunk<RootState, Promise<void>> =>
     async dispatch => {
-        logger.debug(
-            `${device.serialNumber} on ${device.serialport?.comName} is now in DFU-Bootloader...`
-        );
+        logger.debug(`${device.serialNumber} on is now in DFU-Bootloader...`);
         const { application, softdevice } = dfu;
         const params: Partial<InitPacket> = dfu.params || {};
 
@@ -545,9 +544,9 @@ export const sdfuDeviceSetup = (
     dfuFirmware: DfuEntry[],
     needSerialport = false
 ): DeviceSetup => ({
-    supportsProgrammingMode: (device: Device) =>
-        ((!!device.dfuTriggerVersion &&
-            device.dfuTriggerVersion.semVer.length > 0) ||
+    supportsProgrammingMode: (device, deviceInfo) =>
+        ((!!deviceInfo?.dfuTriggerVersion &&
+            deviceInfo.dfuTriggerVersion.semVer.length > 0) ||
             isDeviceInDFUBootloader(device)) &&
         (needSerialport === device.traits.serialPorts || !needSerialport),
     getFirmwareOptions: device =>
@@ -559,31 +558,26 @@ export const sdfuDeviceSetup = (
                     programDeviceWithFw(device, firmwareOption, onProgress)
                 ),
         })),
-    isExpectedFirmware: (device: Device) => () =>
-        new Promise<{
-            device: Device;
-            validFirmware: boolean;
-        }>(resolve => {
-            if (device.dfuTriggerVersion) {
-                logger.debug(
-                    'Device has DFU trigger interface, the device is in Application mode'
-                );
+    isExpectedFirmware: (device, deviceInfo) => () => {
+        if (deviceInfo?.dfuTriggerVersion) {
+            logger.debug(
+                'Device has DFU trigger interface, the device is in Application mode'
+            );
 
-                const { semVer } = device.dfuTriggerVersion;
+            const { semVer } = deviceInfo.dfuTriggerVersion;
 
-                resolve({
-                    device,
-                    validFirmware:
-                        dfuFirmware.filter(fw => fw.semver === semVer).length >
-                        0,
-                });
-            } else {
-                resolve({
-                    device,
-                    validFirmware: false,
-                });
-            }
-        }),
+            return Promise.resolve({
+                device,
+                validFirmware:
+                    dfuFirmware.filter(fw => fw.semver === semVer).length > 0,
+            });
+        }
+
+        return Promise.resolve({
+            device,
+            validFirmware: false,
+        });
+    },
     tryToSwitchToApplicationMode: device => dispatch =>
         new Promise<Device>((resolve, reject) => {
             dispatch(switchToApplicationMode(device, resolve, reject));

package/src/Dropdown/Dropdown.tsx

@@ -11,9 +11,9 @@ import classNames from '../utils/classNames';
 
 import styles from './Dropdown.module.scss';
 
-export interface DropdownItem {
+export interface DropdownItem<T = string> {
     label: React.ReactNode;
-    value: string;
+    value: T;
 }
 
 export interface DropdownProps {

package/src/InlineInput/InlineInput.tsx

@@ -57,6 +57,9 @@ interface Props {
     onKeyboardIncrementAction?: () => string;
     onKeyboardDecrementAction?: () => string;
     className?: string;
+    textAlignLeft?: boolean;
+    onValidityChanged?: (validity: boolean) => void;
+    preventDefaultInvalidStyle?: boolean;
 }
 
 const InlineInput = React.forwardRef<HTMLInputElement, Props>(
@@ -70,19 +73,28 @@ const InlineInput = React.forwardRef<HTMLInputElement, Props>(
             onKeyboardIncrementAction = () => externalValue,
             onKeyboardDecrementAction = () => externalValue,
             className = '',
+            textAlignLeft = false,
+            onValidityChanged,
+            preventDefaultInvalidStyle,
         },
         ref
     ) => {
         const [internalValue, setInternalValue] = useState(externalValue);
         const [initialValue, setInitialValue] = useState(externalValue);
         useSynchronisationIfChangedFromOutside(externalValue, setInternalValue);
+
         const onChangeIfValid = (newValue: string) => {
             if (disabled) {
                 return;
             }
 
+            const validity = isValid(newValue);
+            if (onValidityChanged != null) {
+                onValidityChanged(validity);
+            }
+
             setInternalValue(newValue);
-            if (isValid(newValue)) {
+            if (validity) {
                 if (externalValue !== newValue) {
                     onChange(newValue);
                 }
@@ -94,7 +106,9 @@ const InlineInput = React.forwardRef<HTMLInputElement, Props>(
                 return;
             }
 
-            if (isValid(internalValue)) {
+            const validity = isValid(internalValue);
+
+            if (validity) {
                 if (initialValue !== internalValue) {
                     setInitialValue(internalValue);
                     onChangeComplete(internalValue);
@@ -102,6 +116,11 @@ const InlineInput = React.forwardRef<HTMLInputElement, Props>(
             } else {
                 setInternalValue(externalValue);
             }
+
+            // Should always end up valid in this case
+            if (onValidityChanged != null) {
+                onValidityChanged(true);
+            }
         };
 
         const onChangeCompleteIfValid = (event: React.KeyboardEvent) => {
@@ -144,8 +163,11 @@ const InlineInput = React.forwardRef<HTMLInputElement, Props>(
                 type="text"
                 className={classNames(
                     'inline-input',
-                    isValid(internalValue) || 'invalid',
+                    preventDefaultInvalidStyle
+                        ? null
+                        : isValid(internalValue) || 'invalid',
                     disabled && 'disabled',
+                    textAlignLeft && 'tw-pl-2 tw-text-left',
                     className
                 )}
                 size={

package/src/InlineInput/NumberInlineInput.tsx

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import React, { FC } from 'react';
+import React from 'react';
 
 import { isFactor } from '../Slider/factor';
 import {
@@ -19,12 +19,16 @@ import InlineInput from './InlineInput';
 
 import './number-inline-input.scss';
 
-export interface Props {
+interface NumberInlineInput {
     disabled?: boolean;
     value: number;
     range: RangeOrValues;
+    className?: string;
     onChange: (value: number) => void;
     onChangeComplete?: (value: number) => void;
+    textAlignLeft?: boolean;
+    onValidityChanged?: (validity: boolean) => void;
+    preventDefaultInvalidStyle?: boolean;
 }
 
 const isInValues = (value: number, values: Values) => values.includes(value);
@@ -77,21 +81,24 @@ const changeValueStepwise = (
     return nextValue != null ? nextValue : current;
 };
 
-const NumberInlineInput: FC<Props> = ({
+export default ({
     disabled,
     value,
     range,
+    className,
     onChange,
     onChangeComplete = () => {},
-}) => {
+    textAlignLeft,
+    onValidityChanged,
+    preventDefaultInvalidStyle,
+}: NumberInlineInput) => {
     useValidatedRangeOrValues(range);
 
     return (
         <InlineInput
-            className="number-inline-input"
+            className={`${className} number-inline-input`}
             disabled={disabled}
             value={String(value)}
-            isValid={newValue => isValid(Number(newValue), range)}
             onChange={newValue => onChange(Number(newValue))}
             onChangeComplete={newValue => onChangeComplete(Number(newValue))}
             onKeyboardIncrementAction={() =>
@@ -100,8 +107,17 @@ const NumberInlineInput: FC<Props> = ({
             onKeyboardDecrementAction={() =>
                 changeValueStepwise(value, range, -1).toString()
             }
+            textAlignLeft={textAlignLeft}
+            isValid={newValue => {
+                const validity = isValid(Number(newValue), range);
+                if (onValidityChanged != null) {
+                    // Then propagate the validity back to parent
+                    onValidityChanged(validity);
+                }
+                return validity;
+            }}
+            onValidityChanged={onValidityChanged}
+            preventDefaultInvalidStyle={preventDefaultInvalidStyle}
         />
     );
 };
-
-export default NumberInlineInput;

package/src/InlineInput/NumberInputWithDropdown.tsx

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import React, { useState } from 'react';
+
+import { DropdownItem } from '../Dropdown/Dropdown';
+import { RangeOrValues } from '../Slider/range';
+import classNames from '../utils/classNames';
+import NumberInlineInput from './NumberInlineInput';
+
+import styles from '../Dropdown/Dropdown.module.scss';
+
+export type NumberDropdownItem = DropdownItem<number>;
+
+interface DropdownProps {
+    id?: string;
+    label?: React.ReactNode;
+    items: NumberDropdownItem[];
+    value: number;
+    onChange: (value: number) => void;
+    range: RangeOrValues;
+    numItemsBeforeScroll?: number;
+    className?: string;
+    disabled?: boolean;
+    title?: string;
+}
+
+export default ({
+    id,
+    label,
+    items,
+    value,
+    onChange,
+    range,
+    numItemsBeforeScroll = 0,
+    className = '',
+    disabled = false,
+    title,
+}: DropdownProps) => {
+    const [isActive, setIsActive] = useState(false);
+    const [inlineValue, setInlineValue] = useState(value);
+    const [isValid, setIsValid] = useState(true);
+
+    const setNewValue = (newValue: number) => {
+        setInlineValue(newValue);
+        onChange(newValue);
+        setIsActive(false);
+    };
+    const onClickItem = (item: NumberDropdownItem) => {
+        if (item.value != null && typeof item.value === 'number') {
+            setNewValue(item.value);
+        }
+    };
+
+    return (
+        <div
+            className={`tw-preflight tw-relative tw-w-full ${className}`}
+            onBlur={event => {
+                if (!event.currentTarget.contains(event.relatedTarget)) {
+                    setIsActive(false);
+                }
+            }}
+            title={title}
+        >
+            <div className="tw-mb-1 tw-text-xs">{label}</div>
+            <div className="tw-flex tw-h-8 tw-w-full">
+                <NumberInlineInput
+                    value={inlineValue}
+                    range={range}
+                    onChange={val => setInlineValue(val)}
+                    onChangeComplete={val => setNewValue(val)}
+                    className={`tw-x-2 tw-h-full tw-w-full tw-bg-gray-700 tw-text-white tw-underline tw-underline-offset-2 ${
+                        isValid ? 'tw-decoration-white' : 'tw-decoration-red'
+                    }`}
+                    textAlignLeft
+                    onValidityChanged={setIsValid}
+                    preventDefaultInvalidStyle
+                />
+                <button
+                    id={id}
+                    type="button"
+                    className="tw-overflow-hidden tw-border-b tw-border-solid tw-border-b-gray-200 tw-bg-gray-700 tw-px-2 tw-text-white"
+                    onClick={() => setIsActive(!isActive)}
+                    disabled={disabled}
+                >
+                    <span
+                        className={`mdi mdi-chevron-down tw-text-lg ${classNames(
+                            isActive && 'tw-rotate-180'
+                        )}`}
+                    />
+                </button>
+            </div>
+            {/* eslint-disable-next-line jsx-a11y/no-static-element-interactions -- We need an interactive handler as described below */}
+            <div
+                onMouseDown={ev => {
+                    // To prevent the dropdown from closing when users click on the scrollbar of the items
+                    ev.preventDefault();
+                }}
+                style={
+                    numItemsBeforeScroll > 0
+                        ? {
+                              maxHeight: `${numItemsBeforeScroll * 24}px`,
+                          }
+                        : {}
+                }
+                data-height={
+                    numItemsBeforeScroll > 0 &&
+                    items.length > numItemsBeforeScroll
+                }
+                className={`tw-text-while tw-absolute tw-right-0 tw-z-10 tw-w-full tw-bg-gray-700 tw-p-0 ${classNames(
+                    styles.content,
+                    !isActive && 'tw-hidden'
+                )}`}
+            >
+                {items.map(item => (
+                    <button
+                        type="button"
+                        className="tw-bg-transparent tw-clear-both tw-block tw-h-6 tw-w-full tw-whitespace-nowrap tw-border-0 tw-px-2 tw-py-1 tw-text-left tw-font-normal tw-text-white hover:tw-bg-gray-600 focus:tw-bg-gray-600"
+                        key={item.value}
+                        onClick={() => onClickItem(item)}
+                    >
+                        {item.label}
+                    </button>
+                ))}
+            </div>
+        </div>
+    );
+};

package/src/index.ts

@@ -48,6 +48,8 @@ export { Group, CollapsibleGroup } from './SidePanel/Group';
 export { default as InlineInput } from './InlineInput/InlineInput';
 export { default as NumberInlineInput } from './InlineInput/NumberInlineInput';
 export { default as NumberInputSliderWithUnit } from './NumberInputWithSlider/NumberInputSliderWithUnit';
+export { default as NumberInputWithDropdown } from './InlineInput/NumberInputWithDropdown';
+export type { NumberDropdownItem } from './InlineInput/NumberInputWithDropdown';
 
 export { default as Spinner } from './Spinner/Spinner';
 
@@ -101,6 +103,7 @@ export { sdfuDeviceSetup } from './Device/sdfuOperations';
 
 export {
     selectedDevice,
+    selectedDeviceInfo,
     getReadbackProtection,
     persistSerialPortOptions,
     type Device,

package/src/logging/sendInitialLogMessages.ts

@@ -7,7 +7,7 @@
 import { inMain as appDetails } from '../../ipc/appDetails';
 import NrfutilDeviceLib from '../../nrfutil/device/device';
 import {
-    describeVersion,
+    getExpectedVersion,
     resolveModuleVersion,
 } from '../../nrfutil/moduleVersion';
 import { getAppDataDir } from '../utils/appDirs';
@@ -34,7 +34,6 @@ export default async () => {
         installed,
         homeDir,
         tmpDir,
-        bundledJlink,
         source,
     } = details;
 
@@ -47,16 +46,21 @@ export default async () => {
     logger.debug(`HomeDir: ${homeDir}`);
     logger.debug(`TmpDir: ${tmpDir}`);
 
-    if (bundledJlink) {
-        const dependencies = (await NrfutilDeviceLib.getModuleVersion())
-            .dependencies;
-        const jlinkVersion = resolveModuleVersion('JlinkARM', dependencies);
+    const dependencies = (await NrfutilDeviceLib.getModuleVersion())
+        .dependencies;
+    const jlinkVersion = resolveModuleVersion('JlinkARM', dependencies);
 
-        if (!describeVersion(jlinkVersion).includes(bundledJlink)) {
-            logger.info(
-                `Installed JLink version does not match the provided version (${bundledJlink})`
+    if (jlinkVersion) {
+        const result = getExpectedVersion(jlinkVersion);
+        if (!result.isExpectedVersion) {
+            logger.warn(
+                `Installed JLink version does not match the expected version (${result.expectedVersion})`
             );
         }
+    } else {
+        logger.warn(
+            `JLink is not installed. Please install JLink from: https://www.segger.com/downloads/jlink`
+        );
     }
 
     if (!udevInstalled()) {

package/src/utils/logLibVersions.ts

@@ -91,7 +91,7 @@ export default async () => {
                     `It looks like you have installed JLink using ${JLinkInstallerVersion}, but currently we only support their Universal Installer for your system.`
                 );
                 logger.warn(
-                    `Please install JLink: https://www.segger.com/downloads/jlink/JLink_MacOSX_V780c_universal.pkg`
+                    `Please install JLink: https://www.segger.com/downloads/jlink/JLink_MacOSX_V788j_universal.pkg`
                 );
             }
         }

package/src/utils/systemReport.ts

@@ -89,7 +89,7 @@ const allDevicesReport = (allDevices: Device[] = []) => [
     ...allDevices.map(
         d =>
             `    - ${d.serialNumber} ${
-                d.jlink?.boardVersion || ''
+                d.devkit?.boardVersion || ''
             }: ${d.serialPorts?.map(s => s.comName).join(', ')}`
     ),
     '',
@@ -129,14 +129,14 @@ export const generateSystemReport = async (
 export default async (
     allDevices: Device[],
     currentSerialNumber: string,
-    currentDevice: Device | null
+    currentDevice?: Device
 ) => {
     logger.info('Generating system report...');
     const timestamp = new Date().toISOString().replace(/:/g, '-');
     const report = await generateSystemReport(
         timestamp,
         allDevices,
-        currentDevice ?? undefined,
+        currentDevice,
         currentSerialNumber
     );
 

package/typings/generated/nrfutil/device/__mocks__/device.d.ts

@@ -2,6 +2,7 @@
 declare const _default: {
     program: jest.Mock<any, any, any>;
     programBuffer: jest.Mock<any, any, any>;
+    deviceInfo: jest.Mock<Promise<{}>, [], any>;
     erase: jest.Mock<any, any, any>;
     recover: jest.Mock<any, any, any>;
     reset: jest.Mock<any, any, any>;

package/typings/generated/nrfutil/device/__mocks__/device.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../../../../nrfutil/device/__mocks__/device.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAyBA,wBAiBE"}
+{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../../../../nrfutil/device/__mocks__/device.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA0BA,wBAkBE"}

package/typings/generated/nrfutil/device/batch.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { TaskEnd } from '../sandboxTypes';
 import { Callbacks } from './batchTypes';
-import { DeviceCore, DeviceTraits, NrfutilDeviceWithSerialnumber, ResetKind } from './common';
+import { DeviceCore, DeviceTraits, NrfutilDevice, ResetKind } from './common';
 import { DeviceCoreInfo } from './getCoreInfo';
 import { FWInfo } from './getFwInfo';
 import { GetProtectionStatusResult } from './getProtectionStatus';
@@ -10,6 +10,7 @@ export declare class Batch {
     private operationBatchGeneration;
     private collectOperations;
     private enqueueBatchOperationObject;
+    getDeviceInfo(core: DeviceCore, callbacks?: Callbacks<FWInfo>): this;
     erase(core: DeviceCore, callbacks?: Callbacks): this;
     firmwareRead(core: DeviceCore, callbacks?: Callbacks<Buffer>): this;
     getCoreInfo(core: DeviceCore, callbacks?: Callbacks<DeviceCoreInfo>): this;
@@ -19,6 +20,6 @@ export declare class Batch {
     recover(core: DeviceCore, callbacks?: Callbacks): this;
     reset(core: DeviceCore, reset?: ResetKind, callbacks?: Callbacks): this;
     collect(count: number, callback: (completedTasks: TaskEnd<unknown>[]) => void): this;
-    run(device: NrfutilDeviceWithSerialnumber, controller?: AbortController | undefined): Promise<unknown[]>;
+    run(device: NrfutilDevice, controller?: AbortController | undefined): Promise<unknown[]>;
 }
 //# sourceMappingURL=batch.d.ts.map