@onekeyfe/hd-core 1.1.26-alpha.9 → 1.1.27-alpha.30

package/src/inject.ts

@@ -103,7 +103,7 @@ export const createCoreApi = (
   /**
    * 搜索设备
    */
-  searchDevices: () => call({ method: 'searchDevices' }),
+  searchDevices: params => call({ ...params, method: 'searchDevices' }),
 
   /**
    * 获取设备信息
@@ -148,6 +148,45 @@ export const createCoreApi = (
   deviceFlags: (connectId, params) => call({ ...params, connectId, method: 'deviceFlags' }),
   deviceRebootToBoardloader: connectId => call({ connectId, method: 'deviceRebootToBoardloader' }),
   deviceRebootToBootloader: connectId => call({ connectId, method: 'deviceRebootToBootloader' }),
+
+  // File system & device control API (Protocol V2 only)
+  getProtoVersion: (connectId, params) => call({ ...params, connectId, method: 'getProtoVersion' }),
+  ping: (connectId, params) => call({ ...params, connectId, method: 'ping' }),
+  devReboot: (connectId, params) => call({ ...params, connectId, method: 'devReboot' }),
+  devGetDeviceInfo: (connectId, params) =>
+    call({ ...params, connectId, method: 'devGetDeviceInfo' }),
+  devGetOnboardingStatus: (connectId, params) =>
+    call({ ...params, connectId, method: 'devGetOnboardingStatus' }),
+  devFirmwareUpdate: (connectId, params) =>
+    call({ ...params, connectId, method: 'devFirmwareUpdate' }),
+  devGetFirmwareUpdateStatus: (connectId, params) =>
+    call({ ...params, connectId, method: 'devGetFirmwareUpdateStatus' }),
+  factoryDeviceInfoSettings: (connectId, params) =>
+    call({ ...params, connectId, method: 'factoryDeviceInfoSettings' }),
+  factoryGetDeviceInfo: connectId => call({ connectId, method: 'factoryGetDeviceInfo' }),
+  filesystemFixPermission: connectId => call({ connectId, method: 'filesystemFixPermission' }),
+  fileRead: (connectId, params) => call({ ...params, connectId, method: 'fileRead' }),
+  fileWrite: (connectId, params) => call({ ...params, connectId, method: 'fileWrite' }),
+  fileDelete: (connectId, params) => call({ ...params, connectId, method: 'fileDelete' }),
+  dirList: (connectId, params) => call({ ...params, connectId, method: 'dirList' }),
+  dirMake: (connectId, params) => call({ ...params, connectId, method: 'dirMake' }),
+  dirRemove: (connectId, params) => call({ ...params, connectId, method: 'dirRemove' }),
+  pathInfo: (connectId, params) => call({ ...params, connectId, method: 'pathInfo' }),
+  filesystemFileRead: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemFileRead' }),
+  filesystemFileWrite: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemFileWrite' }),
+  filesystemFileDelete: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemFileDelete' }),
+  filesystemDirList: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemDirList' }),
+  filesystemDirMake: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemDirMake' }),
+  filesystemDirRemove: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemDirRemove' }),
+  filesystemPathInfoQuery: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemPathInfoQuery' }),
+  filesystemFormat: connectId => call({ connectId, method: 'filesystemFormat' }),
   deviceRecovery: (connectId, params) => call({ ...params, connectId, method: 'deviceRecovery' }),
   deviceReset: (connectId, params) => call({ ...params, connectId, method: 'deviceReset' }),
   deviceSettings: (connectId, params) => call({ ...params, connectId, method: 'deviceSettings' }),
@@ -260,6 +299,8 @@ export const createCoreApi = (
     call({ ...params, connectId, method: 'firmwareUpdateV2' }),
   firmwareUpdateV3: (connectId, params) =>
     call({ ...params, connectId, method: 'firmwareUpdateV3' }),
+  firmwareUpdateV4: (connectId, params) =>
+    call({ ...params, connectId, method: 'firmwareUpdateV4' }),
   promptWebDeviceAccess: params => call({ ...params, method: 'promptWebDeviceAccess' }),
 
   tronGetAddress: (connectId, deviceId, params) =>

package/src/protocols/protocol-v2/features.ts

@@ -0,0 +1,266 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import type { Features } from '../../types';
+import type { DeviceCommands } from '../../device/DeviceCommands';
+import type { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+
+type ProtocolV2Bytes = Uint8Array | number[] | string;
+
+type ProtocolV2FirmwareImageInfo = {
+  version?: string;
+  build_id?: string;
+  hash?: ProtocolV2Bytes;
+};
+
+type ProtocolV2SEInfo = {
+  boot?: ProtocolV2FirmwareImageInfo;
+  app?: ProtocolV2FirmwareImageInfo;
+  type?: number;
+  state?: number;
+};
+
+type ProtocolV2DeviceInfo = {
+  protocol_version?: number;
+  hw?: {
+    device_type?: number;
+    serial_no?: string;
+    hardware_version?: string;
+    hardware_version_raw_adc?: number;
+  };
+  fw?: {
+    board?: ProtocolV2FirmwareImageInfo;
+    boot?: ProtocolV2FirmwareImageInfo;
+    app?: ProtocolV2FirmwareImageInfo;
+  };
+  bt?: {
+    boot?: ProtocolV2FirmwareImageInfo;
+    app?: ProtocolV2FirmwareImageInfo;
+    adv_name?: string;
+    mac?: ProtocolV2Bytes;
+  };
+  se1?: ProtocolV2SEInfo;
+  se2?: ProtocolV2SEInfo;
+  se3?: ProtocolV2SEInfo;
+  se4?: ProtocolV2SEInfo;
+  status?: {
+    language?: string;
+    bt_enable?: boolean;
+    init_states?: boolean;
+    backup_required?: boolean;
+    passphrase_protection?: boolean;
+    label?: string;
+  };
+};
+
+// const PROTOCOL_V2_DEVICE_INFO_REQUEST = {
+//   targets: {
+//     hw: true,
+//     fw: true,
+//     bt: true,
+//     se1: true,
+//     se2: true,
+//     se3: true,
+//     se4: true,
+//     status: true,
+//   },
+//   types: {
+//     version: true,
+//     build_id: true,
+//     hash: true,
+//     specific: true,
+//   },
+// };
+
+function parseVersion(version?: string | null): [number, number, number] {
+  if (!version) return [0, 0, 0];
+  const [major = 0, minor = 0, patch = 0] = version.split('.').map(part => Number(part) || 0);
+  return [major, minor, patch];
+}
+
+function bytesToHex(value: unknown): string | undefined {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (value instanceof Uint8Array) {
+    return Array.from(value)
+      .map(byte => byte.toString(16).padStart(2, '0'))
+      .join('');
+  }
+  if (Array.isArray(value)) {
+    return value.map(byte => Number(byte).toString(16).padStart(2, '0')).join('');
+  }
+  return undefined;
+}
+
+function getDescriptorId(descriptor: DeviceDescriptor) {
+  return descriptor.path || descriptor.id || '';
+}
+
+function getImageVersion(image?: ProtocolV2FirmwareImageInfo) {
+  return image?.version || undefined;
+}
+
+function getImageBuildId(image?: ProtocolV2FirmwareImageInfo) {
+  return image?.build_id || undefined;
+}
+
+function getImageHash(image?: ProtocolV2FirmwareImageInfo) {
+  return bytesToHex(image?.hash);
+}
+
+function getSeState(se?: ProtocolV2SEInfo) {
+  switch (se?.state) {
+    case 0:
+      return 'BOOT';
+    case 51:
+      return 'APP_FACTORY';
+    case 85:
+      return 'APP';
+    default:
+      return null;
+  }
+}
+
+function createBaseFeatures(descriptor: DeviceDescriptor): Features {
+  const descriptorId = getDescriptorId(descriptor);
+  return {
+    vendor: 'onekey.so',
+    major_version: 0,
+    minor_version: 0,
+    patch_version: 0,
+    bootloader_mode: false,
+    device_id: descriptorId,
+    pin_protection: null,
+    passphrase_protection: false,
+    language: null,
+    label: null,
+    initialized: false,
+    revision: null,
+    bootloader_hash: null,
+    imported: null,
+    unlocked: false,
+    firmware_present: false,
+    needs_backup: null,
+    flags: null,
+    model: 'pro2',
+    fw_major: 0,
+    fw_minor: 0,
+    fw_patch: 0,
+    fw_vendor: null,
+    unfinished_backup: null,
+    no_backup: null,
+    recovery_mode: null,
+    capabilities: [],
+    backup_type: null,
+    sd_card_present: null,
+    sd_protection: null,
+    wipe_code_protection: null,
+    session_id: null,
+    passphrase_always_on_device: null,
+    safety_checks: null,
+    auto_lock_delay_ms: null,
+    display_rotation: null,
+    experimental_features: null,
+    onekey_device_type: EDeviceType.Pro2,
+    onekey_serial_no: descriptorId,
+    serial_no: descriptorId,
+  };
+}
+
+export function normalizeProtocolV2Features(
+  descriptor: DeviceDescriptor,
+  deviceInfo?: ProtocolV2DeviceInfo
+): Features {
+  const features = createBaseFeatures(descriptor);
+  if (!deviceInfo) return features;
+
+  const serialNo =
+    deviceInfo.hw?.serial_no || features.onekey_serial_no || getDescriptorId(descriptor);
+  const firmwareVersion = getImageVersion(deviceInfo.fw?.app);
+  const [fwMajor, fwMinor, fwPatch] = parseVersion(firmwareVersion);
+
+  return {
+    ...features,
+    major_version: fwMajor,
+    minor_version: fwMinor,
+    patch_version: fwPatch,
+    fw_major: fwMajor,
+    fw_minor: fwMinor,
+    fw_patch: fwPatch,
+    device_id: serialNo,
+    serial_no: serialNo,
+    onekey_serial_no: serialNo,
+    label: deviceInfo.status?.label ?? features.label,
+    language: deviceInfo.status?.language ?? features.language,
+    initialized: deviceInfo.status?.init_states ?? features.initialized,
+    passphrase_protection:
+      deviceInfo.status?.passphrase_protection ?? features.passphrase_protection,
+    needs_backup: deviceInfo.status?.backup_required ?? features.needs_backup,
+    ble_enable: deviceInfo.status?.bt_enable,
+    onekey_ble_name: deviceInfo.bt?.adv_name,
+    ble_name: deviceInfo.bt?.adv_name,
+    onekey_firmware_version: firmwareVersion,
+    onekey_firmware_build_id: getImageBuildId(deviceInfo.fw?.app),
+    onekey_firmware_hash: getImageHash(deviceInfo.fw?.app),
+    onekey_boot_version: getImageVersion(deviceInfo.fw?.boot),
+    bootloader_version: getImageVersion(deviceInfo.fw?.boot),
+    onekey_boot_build_id: getImageBuildId(deviceInfo.fw?.boot),
+    onekey_boot_hash: getImageHash(deviceInfo.fw?.boot),
+    onekey_board_version: getImageVersion(deviceInfo.fw?.board),
+    onekey_board_hash: getImageHash(deviceInfo.fw?.board),
+    onekey_ble_version: getImageVersion(deviceInfo.bt?.app),
+    ble_ver: getImageVersion(deviceInfo.bt?.app),
+    onekey_ble_build_id: getImageBuildId(deviceInfo.bt?.app),
+    onekey_ble_hash: getImageHash(deviceInfo.bt?.app),
+    onekey_se01_version: getImageVersion(deviceInfo.se1?.app),
+    onekey_se01_hash: getImageHash(deviceInfo.se1?.app),
+    onekey_se01_build_id: getImageBuildId(deviceInfo.se1?.app),
+    onekey_se01_state: getSeState(deviceInfo.se1),
+    onekey_se02_version: getImageVersion(deviceInfo.se2?.app),
+    onekey_se02_state: getSeState(deviceInfo.se2),
+    onekey_se03_version: getImageVersion(deviceInfo.se3?.app),
+    onekey_se03_state: getSeState(deviceInfo.se3),
+    onekey_se04_version: getImageVersion(deviceInfo.se4?.app),
+    onekey_se04_state: getSeState(deviceInfo.se4),
+  };
+}
+
+export async function getProtocolV2Features({
+  commands,
+  descriptor,
+  timeoutMs,
+}: {
+  commands: DeviceCommands;
+  descriptor: DeviceDescriptor;
+  onDeviceInfoError?: (error: unknown) => void;
+  timeoutMs?: number;
+}) {
+  const callOptions = timeoutMs ? { timeoutMs } : undefined;
+  if (callOptions) {
+    await commands.typedCall('Ping', 'Success', { message: 'init' }, callOptions);
+  } else {
+    await commands.typedCall('Ping', 'Success', { message: 'init' });
+  }
+
+  // 当前 Pro2 固件暂不支持 DevGetDeviceInfo，初始化阶段只保留 Ping。
+  // 固件支持后再恢复下面这段 DeviceInfo 读取，用于补全版本、序列号和状态字段。
+  // try {
+  //   const { message } = callOptions
+  //     ? await commands.typedCall(
+  //         'DevGetDeviceInfo',
+  //         'DeviceInfo',
+  //         PROTOCOL_V2_DEVICE_INFO_REQUEST,
+  //         callOptions
+  //       )
+  //     : await commands.typedCall(
+  //         'DevGetDeviceInfo',
+  //         'DeviceInfo',
+  //         PROTOCOL_V2_DEVICE_INFO_REQUEST
+  //       );
+  //   return normalizeProtocolV2Features(descriptor, message as unknown as ProtocolV2DeviceInfo);
+  // } catch (error) {
+  //   onDeviceInfoError?.(error);
+  //   throw error;
+  // }
+
+  return normalizeProtocolV2Features(descriptor);
+}

package/src/protocols/protocol-v2/firmware.ts

@@ -0,0 +1,26 @@
+/**
+ * Protocol V2 DevFirmwareTargetType enum (from messages-pro2.json).
+ */
+export const ProtocolV2FirmwareTargetType = {
+  TARGET_MAIN_APP: 0,
+  TARGET_MAIN_BOOT: 1,
+  TARGET_BT: 2,
+  TARGET_SE1: 3,
+  TARGET_SE2: 4,
+  TARGET_SE3: 5,
+  TARGET_SE4: 6,
+  TARGET_RESOURCE: 10,
+} as const;
+
+/**
+ * Map Protocol V2 firmware file name to DevFirmwareUpdate target_id.
+ */
+export function protocolV2FileNameToTargetId(fileName: string): number {
+  if (fileName.includes('ble')) return ProtocolV2FirmwareTargetType.TARGET_BT;
+  if (fileName.includes('bootloader')) return ProtocolV2FirmwareTargetType.TARGET_MAIN_BOOT;
+  if (fileName.includes('se1')) return ProtocolV2FirmwareTargetType.TARGET_SE1;
+  if (fileName.includes('se2')) return ProtocolV2FirmwareTargetType.TARGET_SE2;
+  if (fileName.includes('se3')) return ProtocolV2FirmwareTargetType.TARGET_SE3;
+  if (fileName.includes('se4')) return ProtocolV2FirmwareTargetType.TARGET_SE4;
+  return ProtocolV2FirmwareTargetType.TARGET_MAIN_APP;
+}

package/src/protocols/protocol-v2/index.ts

@@ -0,0 +1,2 @@
+export * from './features';
+export * from './firmware';

package/src/types/api/export.ts

@@ -28,6 +28,7 @@ export type {
   FirmwareUpdateParams,
   FirmwareUpdateBinaryParams,
   FirmwareUpdateV3Params,
+  FirmwareUpdateV4Params,
 } from './firmwareUpdate';
 export type { AllFirmwareRelease } from './checkAllFirmwareRelease';
 

package/src/types/api/firmwareUpdate.ts

@@ -41,6 +41,7 @@ export declare function firmwareUpdateV2(
 export interface FirmwareUpdateV3Params {
   bleVersion?: number[];
   bleBinary?: ArrayBuffer;
+  chunkSize?: number;
 
   firmwareVersion?: number[];
   firmwareBinary?: ArrayBuffer;
@@ -56,6 +57,8 @@ export interface FirmwareUpdateV3Params {
   platform: IPlatform;
 }
 
+export type FirmwareUpdateV4Params = FirmwareUpdateV3Params;
+
 export declare function firmwareUpdateV3(
   connectId: string | undefined,
   params: Params<FirmwareUpdateV3Params>
@@ -64,3 +67,12 @@ export declare function firmwareUpdateV3(
   firmwareVersion: string;
   bootloaderVersion: string;
 }>;
+
+export declare function firmwareUpdateV4(
+  connectId: string | undefined,
+  params: Params<FirmwareUpdateV4Params>
+): Response<{
+  bleVersion: string;
+  firmwareVersion: string;
+  bootloaderVersion: string;
+}>;

package/src/types/api/index.ts

@@ -1,3 +1,30 @@
+import type {
+  devFirmwareUpdate,
+  devGetDeviceInfo,
+  devGetFirmwareUpdateStatus,
+  devGetOnboardingStatus,
+  devReboot,
+  dirList,
+  dirMake,
+  dirRemove,
+  factoryDeviceInfoSettings,
+  factoryGetDeviceInfo,
+  fileDelete,
+  fileRead,
+  fileWrite,
+  filesystemDirList,
+  filesystemDirMake,
+  filesystemDirRemove,
+  filesystemFileDelete,
+  filesystemFileRead,
+  filesystemFileWrite,
+  filesystemFixPermission,
+  filesystemFormat,
+  filesystemPathInfoQuery,
+  getProtoVersion,
+  pathInfo,
+  ping,
+} from './protocolV2';
 import type { off, on, removeAllListeners } from './event';
 import type { uiResponse } from './uiResponse';
 import type { init, updateSettings } from './init';
@@ -14,7 +41,12 @@ import type { getOnekeyFeatures } from './getOnekeyFeatures';
 import type { getPassphraseState } from './getPassphraseState';
 import type { checkFirmwareRelease } from './checkFirmwareRelease';
 import type { checkBLEFirmwareRelease } from './checkBLEFirmwareRelease';
-import type { firmwareUpdate, firmwareUpdateV2, firmwareUpdateV3 } from './firmwareUpdate';
+import type {
+  firmwareUpdate,
+  firmwareUpdateV2,
+  firmwareUpdateV3,
+  firmwareUpdateV4,
+} from './firmwareUpdate';
 import type { promptWebDeviceAccess } from './promptWebDeviceAccess';
 import type { deviceReset } from './deviceReset';
 import type { deviceRecovery } from './deviceRecovery';
@@ -195,8 +227,38 @@ export type CoreApi = {
   firmwareUpdate: typeof firmwareUpdate;
   firmwareUpdateV2: typeof firmwareUpdateV2;
   firmwareUpdateV3: typeof firmwareUpdateV3;
+  firmwareUpdateV4: typeof firmwareUpdateV4;
   cipherKeyValue: typeof cipherKeyValue;
 
+  /**
+   * File system & device control API (Protocol V2 only)
+   */
+  getProtoVersion: typeof getProtoVersion;
+  ping: typeof ping;
+  devReboot: typeof devReboot;
+  devGetDeviceInfo: typeof devGetDeviceInfo;
+  devGetOnboardingStatus: typeof devGetOnboardingStatus;
+  devFirmwareUpdate: typeof devFirmwareUpdate;
+  devGetFirmwareUpdateStatus: typeof devGetFirmwareUpdateStatus;
+  factoryDeviceInfoSettings: typeof factoryDeviceInfoSettings;
+  factoryGetDeviceInfo: typeof factoryGetDeviceInfo;
+  filesystemFixPermission: typeof filesystemFixPermission;
+  fileRead: typeof fileRead;
+  fileWrite: typeof fileWrite;
+  fileDelete: typeof fileDelete;
+  dirList: typeof dirList;
+  dirMake: typeof dirMake;
+  dirRemove: typeof dirRemove;
+  pathInfo: typeof pathInfo;
+  filesystemFileRead: typeof filesystemFileRead;
+  filesystemFileWrite: typeof filesystemFileWrite;
+  filesystemFileDelete: typeof filesystemFileDelete;
+  filesystemDirList: typeof filesystemDirList;
+  filesystemDirMake: typeof filesystemDirMake;
+  filesystemDirRemove: typeof filesystemDirRemove;
+  filesystemPathInfoQuery: typeof filesystemPathInfoQuery;
+  filesystemFormat: typeof filesystemFormat;
+
   /**
    * All network function
    */

package/src/types/api/protocolV2.ts

@@ -0,0 +1,221 @@
+import type { CommonParams, Response } from '../params';
+import type {
+  DevFirmwareTarget,
+  DevFirmwareUpdateStatus,
+  DevOnboardingStatus,
+  DevInfoTargets,
+  DevInfoTypes,
+  DevRebootType,
+  FactoryDeviceInfo,
+  ProtoVersion,
+  ProtocolV2DeviceInfo,
+  Success,
+} from '@onekeyfe/hd-transport';
+
+// ── Shared response shapes (Protocol V2 file system) ────────────────────
+
+export type FileOpSuccess = { message?: string };
+
+export type FileInfo = {
+  path: string;
+  offset: number;
+  total_size: number;
+  data?: Uint8Array;
+  data_hash?: number;
+  processed_byte?: number;
+  chunks?: number;
+};
+
+export type DirInfo = {
+  path: string;
+  child_dirs?: string;
+  child_files?: string;
+};
+
+export type PathInfoResult = {
+  exist: boolean;
+  size: number;
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+  readonly?: boolean;
+  hidden?: boolean;
+  system?: boolean;
+  archive?: boolean;
+  directory?: boolean;
+};
+
+export type DevRebootParams = {
+  rebootType?: DevRebootType | string | number;
+  reboot_type?: DevRebootType | string | number;
+};
+
+export type DevGetDeviceInfoParams = {
+  targets?: DevInfoTargets;
+  types?: DevInfoTypes;
+  targetHw?: boolean;
+  targetFw?: boolean;
+  targetBt?: boolean;
+  targetSe1?: boolean;
+  targetSe2?: boolean;
+  targetSe3?: boolean;
+  targetSe4?: boolean;
+  targetStatus?: boolean;
+  includeVersion?: boolean;
+  includeBuildId?: boolean;
+  includeHash?: boolean;
+  includeSpecific?: boolean;
+};
+
+export type DevFirmwareUpdateParams = {
+  targets?: DevFirmwareTarget[];
+  targetId?: DevFirmwareTarget['target_id'] | string | number;
+  target_id?: DevFirmwareTarget['target_id'] | string | number;
+  path?: string;
+};
+
+export type FactoryDeviceInfoSettingsParams = {
+  serial_no?: string;
+  serialNo?: string;
+  cpu_info?: string;
+  cpuInfo?: string;
+  pre_firmware?: string;
+  preFirmware?: string;
+};
+
+// ── Method signatures ─────────────────────────────────────────────────────
+
+export declare function fileRead(
+  connectId: string,
+  params: {
+    path: string;
+    offset?: number;
+    totalSize?: number;
+    chunkLen?: number;
+    uiPercentage?: number;
+  }
+): Response<FileInfo>;
+
+export declare function fileWrite(
+  connectId: string,
+  params: {
+    path: string;
+    offset?: number;
+    totalSize?: number;
+    chunkSize?: number;
+    chunkLen?: number;
+    data: ArrayBuffer | Uint8Array | Blob | string;
+    overwrite?: boolean;
+    append?: boolean;
+    uiPercentage?: number;
+  }
+): Response<FileInfo>;
+
+export declare function fileDelete(
+  connectId: string,
+  params: { path: string }
+): Response<FileOpSuccess>;
+
+export declare function dirList(
+  connectId: string,
+  params: { path: string; depth?: number }
+): Response<DirInfo>;
+
+export declare function dirMake(
+  connectId: string,
+  params: { path: string }
+): Response<FileOpSuccess>;
+
+export declare function dirRemove(
+  connectId: string,
+  params: { path: string }
+): Response<FileOpSuccess>;
+
+export declare function pathInfo(
+  connectId: string,
+  params: { path: string }
+): Response<PathInfoResult>;
+
+export declare function getProtoVersion(
+  connectId: string,
+  params?: CommonParams
+): Response<ProtoVersion>;
+
+export declare function ping(
+  connectId: string,
+  params?: CommonParams & { message?: string }
+): Response<Success>;
+
+export declare function devReboot(
+  connectId: string,
+  params: CommonParams & DevRebootParams
+): Response<Success>;
+
+export declare function devGetDeviceInfo(
+  connectId: string,
+  params?: CommonParams & DevGetDeviceInfoParams
+): Response<ProtocolV2DeviceInfo>;
+
+export declare function devGetOnboardingStatus(
+  connectId: string,
+  params?: CommonParams
+): Response<DevOnboardingStatus>;
+
+export declare function devFirmwareUpdate(
+  connectId: string,
+  params: CommonParams & DevFirmwareUpdateParams
+): Response<Success | DevFirmwareUpdateStatus>;
+
+export declare function devGetFirmwareUpdateStatus(
+  connectId: string,
+  params?: CommonParams
+): Response<DevFirmwareUpdateStatus>;
+
+export declare function factoryDeviceInfoSettings(
+  connectId: string,
+  params: FactoryDeviceInfoSettingsParams
+): Response<Success>;
+
+export declare function factoryGetDeviceInfo(connectId: string): Response<FactoryDeviceInfo>;
+
+export declare function filesystemFixPermission(connectId: string): Response<Success>;
+
+export declare function filesystemFileRead(
+  connectId: string,
+  params: Parameters<typeof fileRead>[1]
+): ReturnType<typeof fileRead>;
+
+export declare function filesystemFileWrite(
+  connectId: string,
+  params: Parameters<typeof fileWrite>[1]
+): ReturnType<typeof fileWrite>;
+
+export declare function filesystemFileDelete(
+  connectId: string,
+  params: Parameters<typeof fileDelete>[1]
+): ReturnType<typeof fileDelete>;
+
+export declare function filesystemDirList(
+  connectId: string,
+  params: Parameters<typeof dirList>[1]
+): ReturnType<typeof dirList>;
+
+export declare function filesystemDirMake(
+  connectId: string,
+  params: Parameters<typeof dirMake>[1]
+): ReturnType<typeof dirMake>;
+
+export declare function filesystemDirRemove(
+  connectId: string,
+  params: Parameters<typeof dirRemove>[1]
+): ReturnType<typeof dirRemove>;
+
+export declare function filesystemPathInfoQuery(
+  connectId: string,
+  params: Parameters<typeof pathInfo>[1]
+): ReturnType<typeof pathInfo>;
+
+export declare function filesystemFormat(connectId: string): Response<Success>;