@arkts/image-manager 0.4.3 → 0.5.0

package/dist/index.d.mts

@@ -1,685 +1,1258 @@
-import { a as ParentEmulatorSnakecaseDeviceType, c as SnakecaseDeviceType, d as isPhoneAllSnakecaseDeviceType, i as PCAllSnakecaseDeviceType, l as Stringifiable, n as DeviceType, o as PascalCaseDeviceType, r as OS, s as PhoneAllSnakecaseDeviceType, t as Arch, u as isPCAllSnakecaseDeviceType } from "./types-DD8_iqBV.mjs";
-import { a as GroupPhoneAllEmulatorConfigItem, c as PhoneAllEmulatorConfigItem, i as GroupPCAllEmulatorConfigItem, n as EmulatorConfig, o as PCAllEmulatorConfigItem, r as EmulatorConfigItem, s as ParentEmulatorConfigItem, t as BaseEmulatorConfigItem } from "./emulator-config-DbI3FRE5.mjs";
-import { n as ProductConfigItem, t as ProductConfig } from "./product-config-ByDVg0-5.mjs";
-import { AxiosProgressEvent } from "axios";
-import { Emitter } from "mitt";
-import progress from "progress-stream";
+import { Disposable, FileSystem, FileSystemWatcher } from "vscode-fs";
+import * as axios from "axios";
 import * as node_child_process0 from "node:child_process";
+import child_process from "node:child_process";
 import * as node_crypto0 from "node:crypto";
-import * as node_fs0 from "node:fs";
 import * as node_os0 from "node:os";
-import * as node_path0 from "node:path";
 import * as node_process0 from "node:process";
+import * as node_stream0 from "node:stream";
+import { Readable } from "node:stream";
+import * as unzipper from "unzipper";
+import * as vscode_uri0 from "vscode-uri";
 
-//#region package.json.d.ts
-declare let version: string;
-//#endregion
-//#region src/images/local-image.d.ts
-interface LocalImage extends BaseImage, Stringifiable<LocalImage.Stringifiable> {
-  imageType: 'local';
-  getDevices(): Promise<Device[]>;
-  createDevice(options: Device.Options): Device;
-  delete(): Promise<void | Error>;
-  start(device: Device): Promise<node_child_process0.ChildProcess>;
-  stop(device: Device): Promise<node_child_process0.ChildProcess>;
-  buildStartCommand(device: Device): Promise<string>;
-  buildStopCommand(device: Device): Promise<string>;
-  getPascalCaseDeviceType(): Promise<PascalCaseDeviceType | undefined>;
-  getProductConfig(): Promise<ProductConfigItem[]>;
-}
-declare namespace LocalImage {
-  interface Stringifiable extends Omit<BaseImage.Stringifiable, 'imageType'> {
-    imageType: 'local';
-    executablePath: string;
-  }
-}
-//#endregion
-//#region src/images/remote-image.d.ts
-interface RemoteImage extends BaseImage, Stringifiable<RemoteImage.Stringifiable> {
-  imageType: 'remote';
-}
-declare namespace RemoteImage {
-  interface Stringifiable extends Omit<BaseImage.Stringifiable, 'imageType'> {
-    imageType: 'remote';
-  }
-}
-//#endregion
-//#region src/image-downloader.d.ts
-interface ImageDownloadProgressEvent extends AxiosProgressEvent {
-  /**
-   * The network speed of the download.
-   */
-  network: number;
-  /**
-   * The unit of the network speed.
-   */
-  unit: 'KB' | 'MB';
+//#region src/types/utils.d.ts
+type BaseSerializable<T extends Record<PropertyKey, any>> = { [K in keyof T as K extends `get${infer GetterName}` ? T[K] extends (() => infer R) ? R extends Promise<any> ? never : Uncapitalize<GetterName> : never : never]: K extends `get${string}` ? T[K] extends (() => infer R) ? R extends Promise<any> ? never : R extends Serializable<infer R2> ? R2 : R extends Array<Serializable<infer R2>> ? R2[] : R : never : never };
+/**
+ * A serializable object.
+ */
+interface Serializable<T extends BaseSerializable<T>> {
   /**
-   * The increment of the {@linkcode ImageDownloadProgressEvent.percentage}.
+   * Serialize the object to a JSON object.
    */
-  increment: number;
+  toJSON(): T;
 }
-interface ExtractProgressEvent extends progress.Progress {}
-type ImageDownloadEventMap = {
-  'download-progress': ImageDownloadProgressEvent;
-  'extract-progress': ExtractProgressEvent;
-};
-interface ImageDownloader<T extends BaseImage> extends Emitter<ImageDownloadEventMap> {
-  /**
-   * Start downloading the image.
-   *
-   * @param signal - The abort signal.
-   */
-  startDownload(signal?: AbortSignal): Promise<void>;
-  /**
-   * Check the checksum of the image.
-   *
-   * @param signal - The abort signal.
-   */
-  checkChecksum(signal?: AbortSignal): Promise<boolean>;
-  /**
-   * Extract the image.
-   *
-   * @param signal - The abort signal.
-   * @param symlinkOpenHarmonySdk - If true, symlink the OpenHarmony SDK to the image. Default is `true`.
-   */
-  extract(signal?: AbortSignal, symlinkOpenHarmonySdk?: boolean): Promise<void>;
-  /**
-   * Clean the cache of the image.
-   */
-  clean(): Promise<void>;
-  /**
-   * Get the image.
-   */
-  getImage(): T;
-  /**
-   * Get the URL of the image.
-   */
-  getUrl(): string;
+type DeepPartial<T extends Record<PropertyKey, any>> = { [K in keyof T]?: T[K] extends Record<PropertyKey, any> ? DeepPartial<T[K]> : T[K] };
+//#endregion
+//#region src/common/serializable-content.d.ts
+interface SerializableContent<T extends SerializableContent.Content = SerializableContent.Content> extends Serializable<SerializableContent.Serializable> {
+  getImageManager(): ImageManager;
+  getContent(): T;
+}
+declare namespace SerializableContent {
+  type Content = Record<PropertyKey, any> | Content[];
+  interface Serializable extends BaseSerializable<SerializableContent> {}
 }
 //#endregion
-//#region src/options.d.ts
-interface ImageManagerOptions {
+//#region src/configs/product/product.d.ts
+interface ProductConfigFile extends Serializable<ProductConfigFile.Serializable>, Omit<SerializableFile, 'toJSON'> {
   /**
-   * The base path to store the images.
-   */
-  imageBasePath?: string;
-  /**
-   * The path to store the deployed images.
-   */
-  deployedPath?: string;
-  /**
-   * The base path to store the downloaded images zip files.
+   * Find the product config items by the options.
    *
-   * @default `imageBasePath/cache`
-   */
-  cachePath?: string;
-  /**
-   * The path to store the HarmonyOS SDK.
+   * @param options - The options to find the product config items.
+   * @template DeviceType - The device type to find. Example: `Foldable`, `Phone`.
+   * @template Name - The name to find. Example: `Mate X7`, `Customize`.
+   * @template OtherName - The name to find from other device types. Example: `nova 15 Pro、nova 15 Ultra`, `Customize`.
+   * @description The name is strictly matched with the name in the `productConfig.json` file,
+   * so if your device type and name are not corresponding, you will get a type error on the `name` property.
+   * Sometimes there are some device names that the library hasn't adapted yet, you can still define it in the `name` property,
+   * and it will not trigger a type error. Only when your device name and device type do not correspond to the library, will it trigger a type error.
    *
-   * - In macOS, it will be `/Applications/DevEco-Studio.app/Contents/sdk/default/openharmony` by default;
-   * - In Windows, it will be `C:\Program Files\Huawei\DevEco Studio\sdk\default\openharmony` by default;
-   * - In other platforms, it will be `~/.huawei/Sdk/default/openharmony` by default.
+   * It is useful to prevent you from using the wrong name.
+   * @returns The product config items.
    */
-  sdkPath?: string;
+  findProductConfigItems<DeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, Name extends ProductConfigFile.GenericContent<DeviceType>['name'] = ProductConfigFile.GenericContent<DeviceType>['name'], OtherName extends ProductConfigFile.OtherDeviceTypeNames<DeviceType> = ProductConfigFile.OtherDeviceTypeNames<DeviceType>>(options: ProductConfigFile.FindOptions<DeviceType, Name, OtherName>): ProductConfigItem<DeviceType, Name>[];
   /**
-   * The path to store the HarmonyOS configuration files.
+   * Find the product config item by the options.
    *
-   * - In macOS, it will be `~/Library/Application Support/Huawei/DevEcoStudio6.0` by default;
-   * - In Windows, it will be `%APPDATA%\Roaming\Huawei\DevEcoStudio6.0` by default;
-   * - In other platforms, it will be `~/.huawei/DevEcoStudio6.0` by default.
-   */
-  configPath?: string;
-  /**
-   * The path to store the HarmonyOS log files.
+   * @param options - The options to find the product config item.
+   * @template DeviceType - The device type to find. Example: `Foldable`, `Phone`.
+   * @template Name - The name to find. Example: `Mate X7`, `Customize`.
+   * @template OtherName - The name to find from other device types. Example: `nova 15 Pro、nova 15 Ultra`, `Customize`.
+   * @description The name is strictly matched with the name in the `productConfig.json` file,
+   * so if your device type and name are not corresponding, you will get a type error on the `name` property.
+   * Sometimes there are some device names that the library hasn't adapted yet, you can still define it in the `name` property,
+   * and it will not trigger a type error. Only when your device name and device type do not correspond to the library, will it trigger a type error.
    *
-   * - In macOS, it will be `~/Library/Logs/Huawei/DevEcoStudio6.0` by default;
-   * - In Windows, it will be `%APPDATA%\Local\Huawei\DevEcoStudio6.0\log` by default;
-   * - In other platforms, it will be `~/.huawei/DevEcoStudio6.0/log` by default.
+   * It is useful to prevent you from using the wrong name.
+   * @returns The product config item. If not found will return `undefined`.
    */
-  logPath?: string;
-  /**
-   * The folder to store the emulator executable files.
-   *
-   * It must contain the `Emulator` (In windows, it will be `Emulator.exe`) executable file.
-   *
-   * - In macOS, it will be `/Applications/DevEco-Studio.app/Contents/tools/emulator`;
-   * - In Windows, it will be `C:\Program Files\Huawei\DevEco Studio\tools\emulator`;
-   * - In other platforms, it will be `~/.huawei/Emulator`.
-   */
-  emulatorPath?: string;
-  os?: typeof node_os0;
-  fs?: typeof node_fs0;
-  path?: typeof node_path0;
-  process?: typeof node_process0;
-  crypto?: typeof node_crypto0;
-  child_process?: typeof node_child_process0;
-}
-type ResolvedImageManagerOptions = Required<ImageManagerOptions>;
+  findProductConfigItem<DeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, Name extends ProductConfigFile.GenericContent<DeviceType>['name'] = ProductConfigFile.GenericContent<DeviceType>['name'], OtherName extends ProductConfigFile.OtherDeviceTypeNames<DeviceType> = ProductConfigFile.OtherDeviceTypeNames<DeviceType>>(options: ProductConfigFile.FindOptions<DeviceType, Name, OtherName>): ProductConfigItem<DeviceType, Name> | undefined;
+}
+declare namespace ProductConfigFile {
+  type DeviceType = 'Phone' | 'Tablet' | '2in1' | 'Foldable' | 'WideFold' | 'TripleFold' | '2in1 Foldable' | 'TV' | 'Wearable';
+  type DeviceTypeWithString = DeviceType | (string & {});
+  type PhoneContent = Record<'Phone', ProductConfigItem.PhoneContent[]>;
+  type TabletContent = Record<'Tablet', ProductConfigItem.TabletContent[]>;
+  type TwoInOneContent = Record<'2in1', ProductConfigItem.TwoInOneContent[]>;
+  type FoldableContent = Record<'Foldable', ProductConfigItem.FoldableContent[]>;
+  type WideFoldContent = Record<'WideFold', ProductConfigItem.WideFoldContent[]>;
+  type TripleFoldContent = Record<'TripleFold', ProductConfigItem.TripleFoldContent[]>;
+  type TwoInOneFoldableContent = Record<'2in1 Foldable', ProductConfigItem.TwoInOneFoldableContent[]>;
+  type TVContent = Record<'TV', ProductConfigItem.TVContent[]>;
+  type WearableContent = Record<'Wearable', ProductConfigItem.WearableContent[]>;
+  type WearableKidContent = Record<'WearableKid', ProductConfigItem.WearableKidContent[]>;
+  type Content = PhoneContent & TabletContent & TwoInOneContent & FoldableContent & WideFoldContent & TripleFoldContent & TwoInOneFoldableContent & TVContent & WearableContent & WearableKidContent;
+  type GenericContent<DeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, Name extends ProductConfigItem.NameWithString = Content[DeviceType][number]['name']> = Content[DeviceType][number] extends {
+    name: Name;
+  } ? Content[DeviceType][number] : Content[DeviceType][number];
+  /** Names from device types other than DeviceType. Used to detect ambiguous names like "Customize". */
+  type OtherDeviceTypeNames<DeviceType extends ProductConfigFile.DeviceType> = Exclude<ProductConfigItem.Name, Content[DeviceType][number]['name']>;
+  interface Serializable extends BaseSerializable<ProductConfigFile> {}
+  interface Generic {
+    readonly deviceType: DeviceType;
+    readonly name: ProductConfigItem.NameWithString;
+  }
+  interface FindOptions<DeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, Name extends ProductConfigFile.GenericContent<DeviceType>['name'] = ProductConfigFile.GenericContent<DeviceType>['name'], OtherName extends OtherDeviceTypeNames<DeviceType> = OtherDeviceTypeNames<DeviceType>> {
+    /**
+     * The device type to find.
+     */
+    readonly deviceType?: DeviceType;
+    /**
+     * The name to find.
+     *
+     * @notes
+     *
+     * - Known wrong name (from other device type) → `never` (type error)
+     * - Known correct name → `Name` or `NameWithString` if ambiguous
+     * - Arbitrary string (not in predefined list) → `NameWithString` (allowed)
+     */
+    readonly name?: Name extends OtherName ? never : Name extends Content[DeviceType][number]['name'] ? Name extends OtherName ? ProductConfigItem.NameWithString : Name : ProductConfigItem.NameWithString;
+  }
+  function is(value: unknown): value is ProductConfigFile;
+}
 //#endregion
-//#region src/image-manager.d.ts
-interface ImageManager {
-  /**
-   * Get the resolved options.
-   */
-  getOptions(): ResolvedImageManagerOptions;
+//#region src/configs/product/item.d.ts
+interface ProductConfigItem<DeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, Name extends ProductConfigFile.GenericContent<DeviceType>['name'] = ProductConfigFile.GenericContent<DeviceType>['name']> extends Serializable<ProductConfigItem.Serializable>, Omit<SerializableContent<ProductConfigFile.GenericContent<DeviceType, Name>>, 'toJSON'> {
   /**
-   * Get the images.
+   * Get the product config file of the product.
    *
-   * @param supportVersion - The support version of the images. Default is `6.0-hos-single-9`.
+   * @returns The product config file of the product.
    */
-  getImages(supportVersion?: string): Promise<Image[]>;
+  getProductConfigFile(): ProductConfigFile;
   /**
-   * Get the product config.
+   * Get the camel-case device type of the product.
    *
-   * It will automatically read from the `imageBasePath/productConfig.json` file if it exists.
-   * If the file does not exist, it will use the default product config.
+   * @returns The camel-case device type of the product.
    */
-  getProductConfig(): Promise<ProductConfig>;
+  getDeviceType(): DeviceType;
   /**
-   * Write the product config.
+   * Get the dev model of the product.
    *
-   * @param existSkip - If the file exists, skip writing. Defaults to `false`.
-   */
-  writeDefaultProductConfig(existSkip?: boolean): Promise<void>;
-  /**
-   * Get the emulator config.
+   * - `Phone` → `PHEMU-FD00`
+   * - `Foldable` → `PHEMU-FD01`
+   * - `WideFold` → `PHEMU-FD02`
+   * - `TripleFold` → `PHEMU-FD06`
+   * - `2in1 Foldable` → `PCEMU-FD05`
+   * - `Wearable` → `MCHEMU-AL00CN`
    *
-   * It will automatically read from the `imageBasePath/emulatorConfig.json` file if it exists.
-   * If the file does not exist, it will use the default emulator config.
-   */
-  getEmulatorConfig(): Promise<EmulatorConfig>;
-  /**
-   * Get the operating system.
-   */
-  getOS(): OS;
-  /**
-   * Get the architecture.
+   * Other cases will return `undefined`. It is very important to emulator to identify the device type.
+   * If the dev model is no correct the emulator screen and features maybe have some problems (e.g. the
+   * screen width and height is not correct、the foldable screen cannot be folded, etc.).
    */
-  getArch(): Arch;
-  /**
-   * Check if the emulator is compatible with current image manager.
-   */
-  isCompatible(): Promise<boolean>;
+  getDevModel(): ProductConfigItem.DevModelWithString | undefined;
 }
-declare function createImageManager(options?: ImageManagerOptions): Promise<ImageManager>;
-//#endregion
-//#region src/errors/deploy-error.d.ts
-declare class DeployError extends Error {
-  readonly code: DeployError.Code;
-  readonly message: string;
-  readonly cause?: Error;
-  constructor(code: DeployError.Code, message: string, cause?: Error);
-  getCode(): DeployError.Code;
-}
-declare namespace DeployError {
-  enum Code {
-    DEVICE_ALREADY_DEPLOYED = "DEVICE_ALREADY_DEPLOYED",
-    LIST_JSON_NOT_AN_ARRAY = "LIST_JSON_NOT_AN_ARRAY",
-    CATCHED_ERROR = "CATCHED_ERROR",
-    MAYBE_OPENED_DEVICE_MANAGER_IN_DEVECO_STUDIO = "MAYBE_OPENED_DEVICE_MANAGER_IN_DEVECO_STUDIO",
-    SYMLINK_SDK_PATH_EXISTS = "SYMLINK_SDK_PATH_EXISTS"
+declare namespace ProductConfigItem {
+  type Customize = 'Customize';
+  type PhoneName = 'nova 15 Pro、nova 15 Ultra' | 'nova 15' | 'Mate 80 Pro Max、Mate 80 RS' | 'Mate 80、Mate 80 Pro' | 'Mate 70 Pro、Mate 70 Pro+、Mate 70 RS' | 'Mate 70' | 'Mate 70 Air' | 'Mate 60 Pro、Mate 60 Pro+、Mate 60 RS' | 'Mate 60' | 'Pura 80 Pro、Pura 80 Pro+、Pura 80 Ultra' | 'Pura 80' | 'Pura 70 Pro、Pura 70 Pro+、Pura 70 Ultra' | 'Pura 70' | 'nova 14 Ultra' | 'nova 14 Pro' | 'nova 14' | 'nova 13 Pro' | 'nova 13' | 'nova 12 Pro、nova 12 Ultra' | 'nova 12' | 'Pocket 2' | 'nova flip、nova flip S';
+  type TabletName = 'MatePad Pro 11' | 'MatePad Pro 12' | 'MatePad Pro 13' | 'MatePad 11 S' | 'MatePad Air 12';
+  type TwoInOneName = 'MateBook Pro';
+  type FoldableName = 'Mate X5' | 'Mate X6' | 'Mate X7';
+  type WideFoldName = 'Pura X';
+  type TripleFoldName = 'Mate XT';
+  type TVName = 'TV';
+  type WearableName = 'Wearable';
+  type WearableKidName = 'WearableKid';
+  type TwoInOneFoldableName = 'MateBook Fold';
+  type Name = PhoneName | TabletName | TwoInOneName | FoldableName | WideFoldName | TripleFoldName | TVName | WearableName | TwoInOneFoldableName | WearableKidName | Customize;
+  type NameWithString = Name | (string & {});
+  interface BaseContent {
+    /**
+     * The name of the product.
+     */
+    readonly name: NameWithString;
+    /**
+     * The screen width of the product.
+     */
+    readonly screenWidth: string;
+    /**
+     * The screen height of the product.
+     */
+    readonly screenHeight: string;
+    /**
+     * The screen diagonal of the product.
+     */
+    readonly screenDiagonal: string;
+    /**
+     * The screen density of the product.
+     */
+    readonly screenDensity: string;
+    /**
+     * Whether the product is visible.
+     */
+    readonly visible: boolean;
+    /**
+     * The dev model of the product.
+     */
+    readonly devModel?: string;
+  }
+  interface BaseFoldContent extends BaseContent {
+    /**
+     * The name of the product.
+     */
+    readonly name: FoldableName | WideFoldName | TripleFoldName | TwoInOneFoldableName | Customize;
+    /**
+     * The outer screen width of the product.
+     */
+    readonly outerScreenWidth: string;
+    /**
+     * The outer screen height of the product.
+     */
+    readonly outerScreenHeight: string;
+    /**
+     * The outer screen diagonal of the product.
+     */
+    readonly outerScreenDiagonal: string;
+  }
+  interface PhoneContent extends BaseContent {
+    /**
+     * The name of the product.
+     */
+    readonly name: PhoneName | Customize;
+    /**
+     * The one cutout path of the product.
+     */
+    readonly oneCutoutPath?: string;
   }
+  interface TabletContent extends BaseContent {
+    /**
+     * The name of the product.
+     */
+    readonly name: TabletName | Customize;
+  }
+  interface TwoInOneContent extends BaseContent {
+    /**
+     * The name of the product.
+     */
+    readonly name: TwoInOneName | Customize;
+  }
+  interface FoldableContent extends BaseFoldContent {
+    /**
+     * The name of the product.
+     */
+    readonly name: FoldableName | Customize;
+  }
+  interface WideFoldContent extends BaseFoldContent {
+    /**
+     * The name of the product.
+     */
+    readonly name: WideFoldName;
+    /**
+     * The outer screen width of the product.
+     */
+    readonly outerScreenWidth: string;
+    /**
+     * The outer screen height of the product.
+     */
+    readonly outerScreenHeight: string;
+    /**
+     * The outer screen diagonal of the product.
+     */
+    readonly outerScreenDiagonal: string;
+  }
+  interface TripleFoldContent extends BaseFoldContent {
+    /**
+     * The name of the product.
+     */
+    readonly name: TripleFoldName;
+    /**
+     * The outer screen height of the product.
+     */
+    readonly outerDoubleScreenWidth: string;
+    /**
+     * The outer double screen height of the product.
+     */
+    readonly outerDoubleScreenHeight: string;
+    /**
+     * The outer double screen diagonal of the product.
+     */
+    readonly outerDoubleScreenDiagonal: string;
+  }
+  interface TwoInOneFoldableContent extends BaseFoldContent {
+    /**
+     * The name of the product.
+     */
+    readonly name: TwoInOneFoldableName;
+  }
+  interface TVContent extends BaseContent {
+    /**
+     * The name of the product.
+     */
+    readonly name: TVName;
+  }
+  interface WearableContent extends BaseContent {
+    /**
+     * The name of the product.
+     */
+    readonly name: WearableName;
+  }
+  interface WearableKidContent extends BaseContent {
+    /**
+     * The name of the product.
+     */
+    readonly name: WearableKidName;
+  }
+  type Content = PhoneContent | TabletContent | TwoInOneContent | FoldableContent | WideFoldContent | TripleFoldContent | TwoInOneFoldableContent | TVContent | WearableContent | WearableKidContent;
+  interface Serializable extends BaseSerializable<ProductConfigItem> {}
+  type DevModel = 'MCHEMU-AL00CN' | 'PHEMU-FD00' | 'PHEMU-FD01' | 'PHEMU-FD02' | 'PCEMU-FD05' | 'PHEMU-FD06';
+  type DevModelWithString = DevModel | (string & {});
+  function is(value: unknown): value is ProductConfigItem;
 }
 //#endregion
-//#region src/errors/request-url-error.d.ts
-declare class RequestUrlError extends Error {
-  readonly message: string;
-  readonly code: number;
-  readonly cause?: Error;
-  constructor(message: string, code: number, cause?: Error);
+//#region src/configs/lists/lists.d.ts
+interface ListsFile extends Serializable<ListsFile.Serializable>, Omit<SerializableFile, 'toJSON'> {
+  getListsFileItems(): ListsFileItem[];
+  addListsFileItem(listsFileItem: ListsFileItem.Content): ListsFileItem;
+  deleteListsFileItem(listsFileItem: ListsFileItem): this;
+}
+declare namespace ListsFile {
+  type Content = ListsFileItem.Content[];
+  interface Serializable extends BaseSerializable<ListsFile> {}
+  function is(value: unknown): value is ListsFile;
 }
 //#endregion
-//#region src/images/image.d.ts
-interface BaseImage {
-  getImageManager(): ImageManager;
-  getPath(): string;
-  getArch(): 'arm' | 'x86' | (string & {});
-  getChecksum(): string;
-  getReleaseType(): string;
-  getVersion(): string;
-  getApiVersion(): string;
-  getTargetOS(): string;
-  getTargetVersion(): string;
-  getFsPath(): string;
-  getDeviceType(): DeviceType | (string & {});
-  getSnakecaseDeviceType(): SnakecaseDeviceType | (string & {});
-  getUrl(): Promise<string | RequestUrlError>;
-  isDownloaded(): Promise<boolean>;
-  createDownloader(signal?: AbortSignal): Promise<ImageDownloader<this> | RequestUrlError>;
+//#region src/configs/lists/item.d.ts
+interface ListsFileItem<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> extends Serializable<ListsFileItem.Serializable>, Omit<SerializableContent<ListsFileItem.Content<ProductDeviceType, ProductName>>, 'toJSON'> {
+  getListsFile(): ListsFile;
 }
-declare namespace BaseImage {
-  interface Stringifiable {
-    imageType: ImageType;
-    arch: 'arm' | 'x86' | (string & {});
-    path: string;
-    checksum: string;
-    fsPath: string;
-    version: string;
-    apiVersion: string;
-    targetOS: string;
-    targetVersion: string;
-    deviceType: DeviceType | (string & {});
-    snakecaseDeviceType: SnakecaseDeviceType | (string & {});
+declare namespace ListsFileItem {
+  interface Serializable extends BaseSerializable<ListsFileItem> {}
+  type DeviceType = 'phone' | 'tablet' | '2in1' | 'foldable' | 'widefold' | 'triplefold' | '2in1_foldable' | 'tv' | 'wearable';
+  type DeviceTypeWithString = DeviceType | (string & {});
+  interface Content<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> {
+    /**
+     * Diagonal size.
+     *
+     * @example '1.6'
+     */
+    readonly 'diagonalSize': string;
+    /**
+     * Density.
+     *
+     * @example '320'
+     */
+    readonly 'density': string;
+    /**
+     * Resolution height.
+     *
+     * @example '466'
+     */
+    readonly 'resolutionHeight': string;
+    /**
+     * Resolution width.
+     *
+     * @example '466'
+     */
+    readonly 'resolutionWidth': string;
+    /**
+     * RAM size.
+     *
+     * @example '4096'
+     */
+    readonly 'memoryRamSize': string;
+    /**
+     * CPU number.
+     *
+     * @example '4'
+     */
+    readonly 'cpuNumber': string;
+    /**
+     * Data disk size.
+     *
+     * @example '6144'
+     */
+    readonly 'dataDiskSize': string;
+    /**
+     * Deployed name.
+     *
+     * @example 'Huawei_Wearable'
+     */
+    readonly 'name': string;
+    /**
+     * UUID.
+     *
+     * @example 'ce454934-3a1b-4770-9838-dc85c5d7b6c1'
+     */
+    readonly 'uuid': string;
+    /**
+     * OpenHarmony/HarmonyOS version.
+     *
+     * @example '6.0.1'
+     */
+    readonly 'hw.apiName': string;
+    /**
+     * Device model.
+     *
+     * @example 'MCHEMU-AL00CN'
+     */
+    readonly 'devModel'?: ProductConfigItem.DevModelWithString;
+    /**
+     * Model.
+     *
+     * @example 'Mate 80 Pro Max、Mate 80 RS'
+     */
+    readonly 'model'?: ProductName;
+    /**
+     * Image directory.
+     *
+     * @example 'system-image/HarmonyOS-6.0.1/wearable_arm/'
+     */
+    readonly 'imageDir': string;
+    /**
+     * Image SDK version.
+     *
+     * @example '6.0.0.112'
+     */
+    readonly 'version': string;
+    /**
+     * Device type.
+     *
+     * @example 'wearable', 'phone', 'tablet'
+     */
+    readonly 'type': DeviceTypeWithString;
+    /**
+     * Architecture.
+     *
+     * @example 'arm'
+     */
+    readonly 'abi': string;
+    /**
+     * API version.
+     *
+     * @example '21'
+     */
+    readonly 'apiVersion': string;
+    /**
+     * Deployed path.
+     *
+     * @example '/Users/xxx/.Huawei/Emulator/deployed/Huawei_Wearable'
+     */
+    readonly 'path': string;
+    /**
+     * Show version.
+     *
+     * @example 'HarmonyOS 6.0.1(21)'
+     */
+    readonly 'showVersion': string;
+    /**
+     * HarmonyOS version.
+     *
+     * @example 'HarmonyOS-6.0.1'
+     */
+    readonly 'harmonyOSVersion'?: string;
+    /**
+     * Guest version.
+     *
+     * @example 'HarmonyOS 6.0.1(21)'
+     */
+    readonly 'guestVersion'?: string;
+    /**
+     * Cover resolution width.
+     *
+     * @example '2472'
+     */
+    readonly 'coverResolutionWidth'?: string;
+    /**
+     * Cover resolution height.
+     *
+     * @example '1648'
+     */
+    readonly 'coverResolutionHeight'?: string;
+    /**
+     * Cover diagonal size.
+     *
+     * @example '13.0'
+     */
+    readonly 'coverDiagonalSize'?: string;
+    /**
+     * HarmonyOS SDK path.
+     *
+     * @example '/Applications/DevEco-Studio.app/Contents/sdk'
+     */
+    readonly 'harmonyos.sdk.path': string;
+    /**
+     * HarmonyOS config path.
+     *
+     * @example '/Users/xxx/Library/Application Support/Huawei/DevEcoStudio6.0'
+     */
+    readonly 'harmonyos.config.path': string;
+    /**
+     * HarmonyOS log path.
+     *
+     * @example '/Users/xxx/Library/Logs/Huawei/DevEcoStudio6.0'
+     */
+    readonly 'harmonyos.log.path': string;
+    /**
+     * Additional properties.
+     */
+    readonly [key: string]: any;
   }
+  function is(value: unknown): value is ListsFileItem;
 }
-type Image = LocalImage | RemoteImage;
-type ImageType = 'local' | 'remote';
 //#endregion
-//#region src/screens/base-screen.d.ts
-interface BaseScreen<T extends BaseScreen.Options = BaseScreen.Options> extends Stringifiable<T> {
-  getWidth(): number;
-  setWidth(width: number): this;
-  getHeight(): number;
-  setHeight(height: number): this;
-  getDiagonal(): number;
-  setDiagonal(diagonal: number): this;
-}
-declare namespace BaseScreen {
+//#region src/screens/customize-screen.d.ts
+interface CustomizeScreen extends Serializable<CustomizeScreen.Serializable> {
+  /**
+   * Get the screen preset.
+   *
+   * @returns The screen preset.
+   */
+  getScreenPreset(): ScreenPreset;
+}
+declare namespace CustomizeScreen {
   interface Options {
-    width: number;
-    height: number;
-    diagonal: number;
+    configName: string;
+    diagonalSize: number;
+    resolutionWidth: number;
+    resolutionHeight: number;
+    density: number;
   }
+  interface Serializable extends Omit<BaseSerializable<CustomizeScreen>, 'screenPreset'>, CustomizeScreen.Options {}
+  function is(value: unknown): value is CustomizeScreen;
 }
 //#endregion
-//#region src/screens/cover-screen.d.ts
-interface CoverScreen<T extends CoverScreen.Options = CoverScreen.Options> extends BaseScreen<T> {
-  getScreen(): Screen;
-}
-declare namespace CoverScreen {
-  interface Options extends BaseScreen.Options {}
-  interface Stringifiable extends Options {}
-  function is(value: unknown): value is CoverScreen;
-}
-declare function createCoverScreen(options: CoverScreen.Options, screen: Screen): CoverScreen;
-//#endregion
-//#region src/screens/double-screen.d.ts
-interface DoubleScreen {
-  getScreen(): Screen;
+//#region src/screens/customize-foldable-screen.d.ts
+interface CustomizeFoldableScreen extends Serializable<CustomizeFoldableScreen.Serializable>, Omit<CustomizeScreen, 'toJSON'> {
+  getCoverResolutionWidth(): number;
+  getCoverResolutionHeight(): number;
+  getCoverDiagonalSize(): number;
 }
-declare namespace DoubleScreen {
-  interface Options extends BaseScreen.Options {}
-  interface Stringifiable extends Options {}
-  function is(value: unknown): value is DoubleScreen;
+declare namespace CustomizeFoldableScreen {
+  interface Options {
+    coverResolutionWidth: number;
+    coverResolutionHeight: number;
+    coverDiagonalSize: number;
+  }
+  interface Serializable extends CustomizeScreen.Serializable, CustomizeFoldableScreen.Options {}
+  function is(value: unknown): value is CustomizeFoldableScreen;
 }
-declare function createDoubleScreen(options: DoubleScreen.Options, screen: Screen): DoubleScreen;
 //#endregion
-//#region src/screens/outer-double-screen.d.ts
-interface OuterDoubleScreen extends OuterScreen {
-  getOuterScreen(): OuterScreen;
+//#region src/configs/emulator/emulator-basic-item.d.ts
+interface EmulatorBasicItem extends SerializableContent<EmulatorBasicItem.Content> {
+  getEmulatorFile(): EmulatorFile;
 }
-declare namespace OuterDoubleScreen {
-  interface Options extends OuterScreen.Options {}
-  interface Stringifiable extends Options {}
-  function is(value: unknown): value is OuterDoubleScreen;
+declare namespace EmulatorBasicItem {
+  type DeviceType = '2in1' | 'tablet' | 'tv' | 'wearable' | 'phone';
+  type DeviceTypeWithString = DeviceType | (string & {});
+  interface Content {
+    readonly name: string;
+    readonly deviceType: DeviceType;
+    readonly resolutionWidth: number;
+    readonly resolutionHeight: number;
+    readonly physicalWidth: number;
+    readonly physicalHeight: number;
+    readonly diagonalSize: number;
+    readonly density: number;
+    readonly memoryRamSize: number;
+    readonly datadiskSize: number;
+    readonly procNumber: number;
+    readonly api: number;
+  }
+  function is(value: unknown): value is EmulatorBasicItem;
+  function isDeviceType(value: unknown): value is DeviceType;
+  function isContent(value: unknown): value is Content;
 }
-declare function createOuterDoubleScreen(options: OuterDoubleScreen.Options, outerScreen: OuterScreen): OuterDoubleScreen;
 //#endregion
-//#region src/screens/outer-screen.d.ts
-interface OuterScreen<T extends OuterScreen.Options = OuterScreen.Options> extends BaseScreen<T> {
-  getScreen(): Screen;
-  getOuterDoubleScreen(): OuterDoubleScreen | undefined;
-  setOuterDoubleScreen(outerDoubleScreen: OuterDoubleScreen | OuterDoubleScreen.Options): this;
+//#region src/configs/emulator/emulator-fold-item.d.ts
+interface EmulatorFoldItem extends SerializableContent<EmulatorFoldItem.Content> {
+  getEmulatorFile(): EmulatorFile;
 }
-declare namespace OuterScreen {
-  interface Options extends BaseScreen.Options {
-    double?: OuterDoubleScreen | OuterDoubleScreen.Options;
+declare namespace EmulatorFoldItem {
+  type DeviceType = 'foldable' | '2in1_foldable' | 'triplefold' | 'widefold';
+  interface Content extends Omit<EmulatorBasicItem.Content, 'deviceType'> {
+    readonly deviceType: DeviceType;
+    readonly coverResolutionWidth: number;
+    readonly coverResolutionHeight: number;
+    readonly coverDiagonalSize: number;
   }
-  interface Stringifiable extends Options {}
-  function is(value: unknown): value is OuterScreen;
+  function is(value: unknown): value is EmulatorFoldItem;
+  function isDeviceType(value: unknown): value is DeviceType;
+  function isContent(value: unknown): value is Content;
 }
-declare function createOuterScreen(options: OuterScreen.Options, screen: Screen): OuterScreen;
 //#endregion
-//#region src/screens/single-screen.d.ts
-interface SingleScreen<T extends SingleScreen.Options = SingleScreen.Options> extends BaseScreen<T> {
-  getScreen(): Screen;
+//#region src/configs/emulator/emulator-triplefold-item.d.ts
+interface EmulatorTripleFoldItem extends SerializableContent<EmulatorTripleFoldItem.Content> {
+  getEmulatorFile(): EmulatorFile;
 }
-declare namespace SingleScreen {
-  interface Options extends BaseScreen.Options {}
-  interface Stringifiable extends Options {}
-  function is(value: unknown): value is SingleScreen;
-}
-declare function createSingleScreen(options: SingleScreen.Options, screen: Screen): SingleScreen;
-//#endregion
-//#region src/screens/screen.d.ts
-interface Screen<T extends Screen.Options = Screen.Options> extends BaseScreen<T> {
-  getScreen(): this;
-  getApiVersion(): number;
-  getSnakecaseDeviceType(): SnakecaseDeviceType;
-  getOuterScreen(): OuterScreen | undefined;
-  setOuterScreen(outerScreen: OuterScreen | OuterScreen.Options): this;
-  getCoverScreen(): CoverScreen | undefined;
-  setCoverScreen(coverScreen: CoverScreen | CoverScreen.Options): this;
-  getSingleScreen(): SingleScreen | undefined;
-  setSingleScreen(singleScreen: SingleScreen | SingleScreen.Options): this;
-  getDoubleScreen(): DoubleScreen | undefined;
-  setDoubleScreen(doubleScreen: DoubleScreen | DoubleScreen.Options): this;
-  getDensity(): number;
-  setDensity(density: number): this;
-}
-declare namespace Screen {
-  interface Options extends BaseScreen.Options {
-    density: number;
-    apiVersion: number;
-    deviceType: SnakecaseDeviceType;
-    outer?: OuterScreen | OuterScreen.Options;
-    cover?: CoverScreen | CoverScreen.Options;
-    single?: SingleScreen | SingleScreen.Options;
-    double?: DoubleScreen | DoubleScreen.Options;
+declare namespace EmulatorTripleFoldItem {
+  type DeviceType = 'triplefold';
+  type DeviceTypeWithString = DeviceType;
+  interface Content extends Omit<EmulatorBasicItem.Content, 'deviceType'> {
+    readonly deviceType: DeviceType;
+    readonly singleResolutionWidth: number;
+    readonly singleResolutionHeight: number;
+    readonly singleDiagonalSize: number;
+    readonly doubleResolutionWidth: number;
+    readonly doubleResolutionHeight: number;
+    readonly doubleDiagonalSize: number;
   }
-  interface Stringifiable extends Options {}
-  function is(value: unknown): value is Screen;
+  function is(value: unknown): value is EmulatorTripleFoldItem;
+  function isDeviceType(value: unknown): value is DeviceType;
+  function isContent(value: unknown): value is Content;
 }
-declare function createScreen(options: Screen.Options): Screen;
 //#endregion
-//#region src/screens/emulator-preset.d.ts
-interface EmulatorPreset extends Stringifiable<EmulatorPreset.Stringifiable> {
-  getScreenPreset(): ScreenPreset;
-  getEmulatorConfig(): EmulatorConfigItem;
+//#region src/configs/emulator/group-item.d.ts
+interface EmulatorGroupItem extends SerializableContent<EmulatorGroupItem.Content> {
+  getEmulatorFile(): EmulatorFile;
+  getChildren(): EmulatorFile.DeviceItem[];
 }
-declare namespace EmulatorPreset {
-  interface Stringifiable {
-    emulatorConfig: EmulatorConfigItem;
+declare namespace EmulatorGroupItem {
+  type DeviceType = 'phone_all' | 'pc_all';
+  type DeviceTypeWithString = DeviceType | (string & {});
+  interface Content {
+    readonly name: string;
+    readonly deviceType: DeviceTypeWithString;
+    readonly api: number;
+    readonly children: EmulatorFile.ItemContent[];
   }
+  function is(value: unknown): value is EmulatorGroupItem;
+  function isContent(value: unknown): value is EmulatorGroupItem.Content;
 }
 //#endregion
-//#region src/screens/product-preset.d.ts
-interface ProductPreset extends Stringifiable<ProductPreset.Stringifiable> {
-  getScreenPreset(): ScreenPreset;
-  getProductConfig(): ProductConfigItem;
-  getDeviceType(): PascalCaseDeviceType;
+//#region src/configs/emulator/emulator.d.ts
+interface EmulatorFile extends Serializable<EmulatorFile.Serializable>, Omit<SerializableFile, 'toJSON'> {
+  findDeviceItems<DeviceType extends EmulatorFile.DeviceType>(options?: EmulatorFile.FindDeviceItemOptions<DeviceType extends EmulatorGroupItem.DeviceType ? never : DeviceType>): EmulatorFile.DeviceItem[];
+  findDeviceItem<DeviceType extends EmulatorFile.DeviceType>(options?: EmulatorFile.FindDeviceItemOptions<DeviceType extends EmulatorGroupItem.DeviceType ? never : DeviceType>): EmulatorFile.DeviceItem | undefined;
+  findItems(options?: EmulatorFile.FindItemOptions): EmulatorFile.Item[];
+  findItem(options?: EmulatorFile.FindItemOptions): EmulatorFile.Item | undefined;
+  getItems(): EmulatorFile.Item[];
 }
-declare namespace ProductPreset {
-  interface Stringifiable {
-    product: ProductConfigItem;
-    deviceType: PascalCaseDeviceType;
+declare namespace EmulatorFile {
+  interface Serializable extends BaseSerializable<EmulatorFile> {}
+  type ItemContent = EmulatorBasicItem.Content | EmulatorFoldItem.Content | EmulatorTripleFoldItem.Content;
+  type Content = Array<ContentItem>;
+  type ContentItem = EmulatorGroupItem.Content | ItemContent;
+  type DeviceItem = EmulatorBasicItem | EmulatorFoldItem | EmulatorTripleFoldItem;
+  type Item = EmulatorGroupItem | DeviceItem;
+  type DeviceType = EmulatorBasicItem.DeviceType | EmulatorFoldItem.DeviceType | EmulatorTripleFoldItem.DeviceType;
+  type DeviceTypeWithString = DeviceType | (string & {});
+  type FullDeviceType = DeviceType | EmulatorGroupItem.DeviceType;
+  type FullDeviceTypeWithString = FullDeviceType | (string & {});
+  function is(value: unknown): value is EmulatorFile;
+  function isItemContent(value: unknown): value is EmulatorFile.ItemContent;
+  function isContentItem(value: unknown): value is EmulatorFile.ContentItem;
+  interface FindDeviceItemOptions<DeviceType extends DeviceTypeWithString = DeviceTypeWithString> {
+    /**
+     * The API version to find.
+     */
+    readonly apiVersion?: number;
+    /**
+     * The device type to find.
+     */
+    readonly deviceType?: DeviceType;
+  }
+  interface FindItemOptions {
+    /**
+     * The API version to find.
+     */
+    readonly apiVersion?: number;
+    /**
+     * The device type to find.
+     */
+    readonly fullDeviceType?: FullDeviceTypeWithString;
   }
 }
 //#endregion
 //#region src/screens/screen-preset.d.ts
-interface ScreenPreset extends Stringifiable<ScreenPreset.Stringifiable> {
-  getScreen(): Screen;
-  getEmulatorPreset(): EmulatorPreset | undefined;
-  getProductPreset(): ProductPreset | undefined;
+interface ScreenPreset<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> {
+  /**
+   * Get the emulator item content.
+   *
+   * @returns The emulator item content.
+   */
+  getEmulatorDeviceItem(): EmulatorFile.DeviceItem;
+  /**
+   * Get the product config item content.
+   *
+   * @returns The product config item content.
+   */
+  getProductConfigItem(): ProductConfigItem<ProductDeviceType, ProductName>;
+  /**
+   * Get the customize screen config.
+   *
+   * @returns The customize screen config.
+   */
+  getCustomizeScreenConfig(): CustomizeScreen | CustomizeFoldableScreen | undefined;
 }
 declare namespace ScreenPreset {
-  interface ScreenOptions {
-    screen: Screen;
-    productConfig?: Partial<ProductConfig>;
-    emulatorConfig?: EmulatorConfig;
-  }
-  namespace ScreenOptions {
-    function is(value: unknown): value is ScreenOptions;
-  }
-  interface ProductOptions {
-    image: LocalImage;
-    productConfig: ProductConfigItem;
-    pascalCaseDeviceType: PascalCaseDeviceType;
+  interface Serializable<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> extends BaseSerializable<ScreenPreset<ProductDeviceType, ProductName>> {}
+  interface PresetOptions<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> {
+    /**
+     * The emulator item content.
+     */
+    readonly emulatorDeviceItem: EmulatorFile.DeviceItem;
+    /**
+     * The product config item content.
+     */
+    readonly productConfigItem: ProductConfigItem<ProductDeviceType, ProductName>;
   }
-  namespace ProductOptions {
-    function is(value: unknown): value is ProductOptions;
+  interface CustomizeOptions<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> extends PresetOptions<ProductDeviceType, ProductName> {
+    /**
+     * The customize screen options.
+     */
+    readonly customizeScreen: CustomizeScreen.Options;
   }
-  interface EmulatorOptions {
-    image: LocalImage;
-    emulatorConfig: EmulatorConfigItem;
-  }
-  namespace EmulatorOptions {
-    function is(value: unknown): value is EmulatorOptions;
-  }
-  type Options = ScreenOptions | ProductOptions | EmulatorOptions;
-  interface Stringifiable {
-    emulatorPreset?: EmulatorPreset.Stringifiable;
-    productPreset?: ProductPreset.Stringifiable;
+  interface CustomizeFoldableOptions<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> extends CustomizeOptions<ProductDeviceType, ProductName> {
+    /**
+     * The customize foldable screen options.
+     */
+    readonly customizeFoldableScreen: CustomizeFoldableScreen.Options;
   }
+  type Options<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> = ProductName extends ProductConfigItem.Customize ? ProductDeviceType extends 'Foldable' ? CustomizeFoldableOptions<ProductDeviceType, ProductName> : CustomizeOptions<ProductDeviceType, ProductName> : PresetOptions<ProductDeviceType, ProductName>;
   function is(value: unknown): value is ScreenPreset;
 }
+//#endregion
+//#region src/devices/device.d.ts
+interface Device<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> extends Serializable<Device.Serializable<ProductDeviceType, ProductName>> {
+  /** Get the screen of the device. */
+  getScreen(): ScreenPreset<ProductDeviceType, ProductName>;
+  /** Get the image manager of the device. */
+  getImageManager(): ImageManager;
+  /** Get the lists file of the device. */
+  getListsFile(): ListsFile;
+  /** Get the lists file item of the device. */
+  getListsFileItem(): ListsFileItem;
+  /** Get the config INI file of the device. */
+  getConfigIniFile(): ConfigIniFile<ProductDeviceType, ProductName>;
+  /** Get the named INI file of the device. */
+  getNamedIniFile(): NamedIniFile<ProductDeviceType, ProductName>;
+  /** Get the executable URI of the device. */
+  getExecutableUri(): vscode_uri0.URI;
+  /** Get the snapshot URI of the device. */
+  getSnapshotUri(): vscode_uri0.URI;
+  /** Get the snapshot base64 string of the device. */
+  getSnapshot(): Promise<string>;
+  /** Get the start command of the device. */
+  getStartCommand(): [string, string[]];
+  /** Get the stop command of the device. */
+  getStopCommand(): [string, string[]];
+  /** Start the device. */
+  start(): Promise<child_process.ChildProcessByStdio<null, Readable, Readable>>;
+  /** Stop the device. */
+  stop(): Promise<child_process.ChildProcessByStdio<null, Readable, Readable>>;
+  /** Delete the device. */
+  delete(): Promise<void>;
+  /** Get the storage size of the device. */
+  getStorageSize(): Promise<number>;
+  /**
+   * Get the watcher of the device.
+   *
+   * - If the watcher is already created, it will return the existing watcher.
+   * - If the watcher is disposed, it will create a new watcher.
+   * - If the watcher is already created but disposed, it will create a new watcher.
+   */
+  getWatcher(): Promise<FileSystemWatcher>;
+}
+declare namespace Device {
+  interface Serializable<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> extends Omit<BaseSerializable<Device<ProductDeviceType, ProductName>>, 'imageManager'> {}
+  function is(value: unknown): value is Device;
+}
+//#endregion
+//#region src/event-emitter.d.ts
 /**
- * Create a screen preset with product options and local image.
+ * Represents a typed event.
  *
- * @param options - The options to create a screen preset.
- */
-declare function createScreenPreset(options: ScreenPreset.ProductOptions): ScreenPreset;
-/**
- * Create a screen preset with emulator options and local image.
+ * A function that represents an event to which you subscribe by calling it with
+ * a listener function as argument.
  *
- * @param options - The options to create a screen preset.
+ * @example
+ * item.onDidChange(function(event) { console.log("Event happened: " + event); });
  */
-declare function createScreenPreset(options: ScreenPreset.EmulatorOptions): ScreenPreset;
-//#endregion
-//#region src/devices/list.d.ts
-declare enum DevModel {
-  MCHEMU_AL00CN = "MCHEMU-AL00CN",
-  PHEMU_FD00 = "PHEMU-FD00",
-  PHEMU_FD01 = "PHEMU-FD01",
-  PHEMU_FD02 = "PHEMU-FD02",
-  PHEMU_FD06 = "PHEMU-FD06",
-  PCEMU_FD00 = "PCEMU-FD00",
-  PCEMU_FD05 = "PCEMU-FD05"
-}
-type DeployedDevModel = 'MCHEMU-AL00CN' | 'PHEMU-FD00' | 'PHEMU-FD01' | 'PHEMU-FD02' | 'PHEMU-FD06' | 'PCEMU-FD00' | 'PCEMU-FD05' | DevModel | (string & {});
-type ProductNameable<T> = T & {
-  /**
-   * The name of the product.
-   *
-   * @example 'Mate 80 Pro Max、Mate 80 RS'
-   */
-  productName: string;
-};
-interface DeployedImageConfig {
+interface Event<T> {
   /**
-   * Diagonal size.
+   * A function that represents an event to which you subscribe by calling it with
+   * a listener function as argument.
    *
-   * @example '1.6'
+   * @param listener The listener function will be called when the event happens.
+   * @param thisArgs The `this`-argument which will be used when calling the event listener.
+   * @param disposables An array to which a {@link Disposable} will be added.
+   * @returns A disposable which unsubscribes the event listener.
    */
-  diagonalSize: string;
+  (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]): Disposable;
+}
+//#endregion
+//#region src/image-downloader.d.ts
+interface ImageDownloader {
+  getRemoteImage(): RemoteImage;
+  getUrl(): string;
+  getCacheUri(): vscode_uri0.URI;
+  startDownload(): Promise<void>;
+  checkChecksum(): Promise<boolean>;
+  extract(): Promise<void>;
+  onDownloadProgress: Event<ImageDownloader.DownloadProgress>;
+  onExtractProgress: Event<ImageDownloader.ExtractProgress>;
+  onChecksumProgress: Event<ImageDownloader.ChecksumProgress>;
+}
+declare namespace ImageDownloader {
+  type ProgressType = 'download' | 'extract';
+  interface BaseProgress {
+    /** Relative progress increment since last report, 0~100. */
+    increment: number;
+    /** Cureent progress, 0~100. */
+    progress: number;
+  }
+  interface DownloadProgress extends BaseProgress {
+    progressType: 'download';
+    /** Current network speed. */
+    network: number;
+    /** Current network speed unit, 'KB' or 'MB'. */
+    unit: 'KB' | 'MB';
+    /**
+     * When true, indicates resume from a previous session. Consumer should set
+     * accumulated progress to this event's `progress` instead of adding `increment`.
+     */
+    reset?: boolean;
+  }
+  interface ExtractProgress extends BaseProgress {
+    progressType: 'extract';
+  }
+  interface ChecksumProgress extends BaseProgress {
+    progressType: 'checksum';
+  }
+}
+//#endregion
+//#region src/sdk-list.d.ts
+declare namespace SDKList {
+  type OS = 'windows' | 'mac' | 'linux';
+  type Arch = 'x86' | 'arm64';
+  interface Request {
+    /**
+     * The architecture of the operating system.
+     */
+    readonly osArch: Arch;
+    /**
+     * The type of the operating system.
+     */
+    readonly osType: OS;
+    /**
+     * The support version of the SDK.
+     */
+    readonly supportVersion: string;
+  }
+  interface RemoteImageSDK {
+    /** @example 'system-image,HarmonyOS-6.0.2,pc_all_x86' */
+    readonly path: `${string},${string},${string}`;
+    /** @example '22' */
+    readonly apiVersion: string;
+    /** @example 'HarmonyOS-SDK' */
+    readonly license: string;
+    /** @example '6.0.0.129' */
+    readonly version: string;
+    /** @example 'System-image-pc_all' */
+    readonly displayName: string;
+    /** @example 'HarmonyOS emulator image for pc_all' */
+    readonly description: string;
+    /** @example '0' */
+    readonly experimentalFlag: string;
+    /** @example 'Beta1' */
+    readonly releaseType: string;
+    /** @example '1.0.0' */
+    readonly metaVersion: string;
+    readonly archive: {
+      complete: {
+        size: '2234888400';
+        checksum: 'd4541e398b61cae48545a95e0fe5bb946d18fd497cd57892e8f8a311568ac8fe';
+        osArch: 'x64';
+      };
+    };
+    /** The additional properties. */
+    readonly [key: string]: unknown;
+  }
+  namespace RemoteImageSDK {
+    interface Archive {
+      complete: Archive.Complete;
+    }
+    namespace Archive {
+      interface Complete {
+        size: string;
+        checksum: string;
+        osArch: string;
+      }
+    }
+  }
+  type OptionalRemoteImageSDK = Partial<RemoteImageSDK>;
+  type OKResponse = RemoteImageSDK[];
+  interface ErrorResponse {
+    /**
+     * The error code.
+     */
+    readonly code: number;
+    /**
+     * The error message.
+     */
+    readonly body: string;
+  }
+  type AxiosResponse = axios.AxiosResponse<OKResponse>;
+  type AxiosError = axios.AxiosError<ErrorResponse>;
+  type Result = AxiosResponse | AxiosError;
+  function isOKResponse(result: Result): result is AxiosResponse;
+  class SDKListError extends Error {
+    readonly code: SDKListError.Code;
+    readonly message: string;
+    readonly cause?: (AxiosError | AxiosResponse) | undefined;
+    constructor(code: SDKListError.Code, message: string, cause?: (AxiosError | AxiosResponse) | undefined);
+  }
+  namespace SDKListError {
+    enum Code {
+      VALIDATION_ERROR = 400,
+      REQUEST_ERROR = 500
+    }
+  }
+}
+//#endregion
+//#region src/images/remote-image.d.ts
+interface RemoteImage extends Serializable<RemoteImage.Serializable>, Omit<BaseImage, 'toJSON'> {
+  readonly imageType: 'remote';
   /**
-   * Density.
+   * Get the remote image SDK.
    *
-   * @example '320'
+   * @returns The remote image SDK.
    */
-  density: string;
+  getRemoteImageSDK(): SDKList.OptionalRemoteImageSDK;
   /**
-   * Resolution height.
+   * Get the local image if it is already downloaded.
    *
-   * @example '466'
+   * @param force - If `true` will reload the local image from the image manager and file system again. Default is `false`.
+   * @returns The local image if it is already downloaded, otherwise `undefined`.
    */
-  resolutionHeight: string;
+  getLocalImage(force?: boolean): Promise<LocalImage | undefined>;
   /**
-   * Resolution width.
+   * Create a downloader for the remote image.
    *
-   * @example '466'
+   * @param signals - The signals to abort the download.
    */
-  resolutionWidth: string;
+  createDownloader(signals?: AbortController): Promise<ImageDownloader>;
 }
-interface DeployedImageConfigWithProductName extends DeployedImageConfig {
-  /**
-   * The name of the product.
-   *
-   * @example 'Mate 80 Pro Max、Mate 80 RS'
-   */
-  productName: string;
+declare namespace RemoteImage {
+  interface Serializable extends BaseImage.Serializable, BaseSerializable<RemoteImage> {}
+  function is(value: unknown): value is RemoteImage;
+}
+//#endregion
+//#region src/images/image.d.ts
+type Image = LocalImage | RemoteImage;
+declare namespace Image {
+  type RelativePath = `system-image/${string}/${string}`;
+  function is(value: unknown): value is Image;
 }
-interface DeployedImageOptions extends DeployedImageConfig {
+//#endregion
+//#region src/images/base-image.d.ts
+interface BaseImage extends Serializable<BaseImage.Serializable> {
   /**
-   * RAM size.
-   *
-   * @example '4096'
+   * The type of the image.
    */
-  'memoryRamSize': string;
+  readonly imageType: 'local' | 'remote';
   /**
-   * CPU number.
-   *
-   * @example '4'
+   * Get the image manager.
    */
-  'cpuNumber': string;
+  getImageManager(): ImageManager;
   /**
-   * Data disk size.
-   *
-   * @example '6144'
+   * Get the relative path of the image.
    */
-  'dataDiskSize': string;
+  getRelativePath(): Image.RelativePath;
   /**
-   * Deployed name.
-   *
-   * @example 'Huawei_Wearable'
+   * Get the full path of the image.
    */
-  'name': string;
+  getFullPath(): vscode_uri0.URI;
   /**
-   * UUID.
-   *
-   * @example 'ce454934-3a1b-4770-9838-dc85c5d7b6c1'
+   * Check if the image is downloaded.
    */
-  'uuid': string;
-  /**
-   * OpenHarmony/HarmonyOS version.
-   *
-   * @example '6.0.1'
-   */
-  'hw.apiName': string;
+  isDownloaded(): Promise<boolean>;
   /**
-   * Device model.
-   *
-   * @example 'MCHEMU-AL00CN'
+   * Get the API version of the image.
    */
-  'devModel'?: DeployedDevModel;
+  getApiVersion(): number;
   /**
-   * Model.
-   *
-   * @example 'Mate 80 Pro Max、Mate 80 RS'
+   * Get the device type of the image.
    */
-  'model'?: string;
+  getFullDeviceType(): EmulatorFile.FullDeviceTypeWithString;
 }
-interface FullDeployedImageOptions extends DeployedImageOptions {
-  /**
-   * Image directory.
-   *
-   * @example 'system-image/HarmonyOS-6.0.1/wearable_arm/'
-   */
-  'imageDir': string;
+declare namespace BaseImage {
+  interface Serializable extends BaseSerializable<BaseImage> {
+    imageType: 'local' | 'remote';
+  }
+  function is(value: unknown): value is BaseImage;
+}
+//#endregion
+//#region src/images/local-image.d.ts
+interface LocalImage extends Serializable<LocalImage.Serializable>, Omit<BaseImage, 'toJSON'> {
+  readonly imageType: 'local';
   /**
-   * Image SDK version.
+   * Get the SDK package file.
    *
-   * @example '6.0.0.112'
+   * @returns The SDK package file.
    */
-  'version': string;
+  getSdkPkgFile(): LocalImage.OptionalSdkPkgFile;
   /**
-   * Device type.
+   * Create a device from the local image.
    *
-   * @example 'wearable', 'phone', 'tablet'
+   * @param options - The options to create the device.
    */
-  'type': SnakecaseDeviceType;
+  createDevice<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']>(options: LocalImage.CreateDeviceOptions<ProductDeviceType, ProductName>): Promise<Device<ProductDeviceType, ProductName>>;
+}
+declare namespace LocalImage {
+  interface Serializable extends BaseImage.Serializable, BaseSerializable<LocalImage> {}
+  interface SdkPkgFile {
+    /**
+     * The SDK package file data.
+     */
+    readonly data: SdkPkgFile.Data;
+  }
+  namespace SdkPkgFile {
+    interface Data {
+      /** @example '13' */
+      readonly apiVersion: string;
+      /** @example 'System-image-foldable' */
+      readonly displayName: string;
+      /** @example 'system-image,HarmonyOS-5.0.1,foldable_arm' */
+      readonly path: string;
+      /** @example '5.0.1' */
+      readonly platformVersion: string;
+      /** @example 'Release' */
+      readonly releaseType: string;
+      /** @example '5.0.0.112' */
+      readonly version: string;
+      /** @example 'HarmonyOS 5.0.0.112(SP2)' */
+      readonly guestVersion: string;
+      /** @example 'Release' */
+      readonly stage: string;
+    }
+  }
+  type OptionalSdkPkgFile = DeepPartial<SdkPkgFile>;
+  interface InfoFile {
+    /** @example '21' */
+    apiVersion: string;
+    /** @example 'arm' */
+    abi: string;
+    /** @example '6.0.0.112' */
+    version: string;
+  }
+  interface CreateDeviceOptions<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> {
+    /**
+     * The name of the device.
+     *
+     * @example 'Huawei_Wearable'
+     */
+    readonly name: string;
+    /**
+     * The CPU number.
+     *
+     * @example 4
+     */
+    readonly cpuNumber: number;
+    /**
+     * The memory RAM size. (in MB)
+     *
+     * @example 4096
+     */
+    readonly memoryRamSize: number;
+    /**
+     * The data disk size. (in MB)
+     *
+     * @example 6144
+     */
+    readonly dataDiskSize: number;
+    /**
+     * The screen.
+     */
+    readonly screen: ScreenPreset.Options<ProductDeviceType, ProductName>;
+    /**
+     * The vendor country.
+     *
+     * @example 'CN'
+     */
+    readonly vendorCountry?: string;
+    /**
+     * @default true
+     */
+    readonly isPublic?: boolean;
+  }
+  function is(value: unknown): value is LocalImage;
+}
+//#endregion
+//#region src/options.d.ts
+type ResolvedImageManagerAdapter = Required<ImageManager.Adapter>;
+type ResolvedImageManagerOptions = Omit<Required<ImageManager.Options>, 'imageBasePath' | 'deployedPath' | 'cachePath' | 'sdkPath' | 'configPath' | 'logPath' | 'emulatorPath'> & {
+  adapter: ResolvedImageManagerAdapter;
+  imageBasePath: vscode_uri0.URI;
+  deployedPath: vscode_uri0.URI;
+  cachePath: vscode_uri0.URI;
+  sdkPath: vscode_uri0.URI;
+  configPath: vscode_uri0.URI;
+  logPath: vscode_uri0.URI;
+  emulatorPath: vscode_uri0.URI;
+};
+//#endregion
+//#region src/image-manager.d.ts
+declare namespace ImageManager {
+  interface Adapter {
+    os?: Pick<typeof node_os0, 'homedir'>;
+    fs?: FileSystem;
+    join?: typeof vscode_uri0.Utils.joinPath;
+    URI?: typeof vscode_uri0.URI;
+    dirname?: typeof vscode_uri0.Utils.dirname;
+    basename?: typeof vscode_uri0.Utils.basename;
+    toWeb?: typeof node_stream0.Readable.toWeb;
+    fromWeb?: typeof node_stream0.Readable.fromWeb;
+    process?: Pick<typeof node_process0, 'platform' | 'env' | 'arch'>;
+    crypto?: Pick<typeof node_crypto0, 'createHash' | 'randomUUID'>;
+    child_process?: Pick<typeof node_child_process0, 'spawn'>;
+    axios?: axios.AxiosInstance;
+    isAxiosError?(error: unknown): error is axios.AxiosError;
+    unzipper?: typeof unzipper;
+  }
+  interface Options {
+    /**
+     * The base path to store the images.
+     */
+    imageBasePath?: string | vscode_uri0.URI;
+    /**
+     * The path to store the deployed images.
+     */
+    deployedPath?: string | vscode_uri0.URI;
+    /**
+     * The base path to store the downloaded images zip files.
+     *
+     * @default `imageBasePath/cache`
+     */
+    cachePath?: string | vscode_uri0.URI;
+    /**
+     * The path to store the HarmonyOS SDK.
+     *
+     * - In macOS, it will be `/Applications/DevEco-Studio.app/Contents/sdk/default/openharmony` by default;
+     * - In Windows, it will be `C:\Program Files\Huawei\DevEco Studio\sdk\default\openharmony` by default;
+     * - In other platforms, it will be `~/.huawei/Sdk/default/openharmony` by default.
+     */
+    sdkPath?: string | vscode_uri0.URI;
+    /**
+     * The path to store the HarmonyOS configuration files.
+     *
+     * - In macOS, it will be `~/Library/Application Support/Huawei/DevEcoStudio6.0` by default;
+     * - In Windows, it will be `%APPDATA%\Roaming\Huawei\DevEcoStudio6.0` by default;
+     * - In other platforms, it will be `~/.huawei/DevEcoStudio6.0` by default.
+     */
+    configPath?: string | vscode_uri0.URI;
+    /**
+     * The path to store the HarmonyOS log files.
+     *
+     * - In macOS, it will be `~/Library/Logs/Huawei/DevEcoStudio6.0` by default;
+     * - In Windows, it will be `%APPDATA%\Local\Huawei\DevEcoStudio6.0\log` by default;
+     * - In other platforms, it will be `~/.huawei/DevEcoStudio6.0/log` by default.
+     */
+    logPath?: string | vscode_uri0.URI;
+    /**
+     * The folder to store the emulator executable files.
+     *
+     * It must contain the `Emulator` (In windows, it will be `Emulator.exe`) executable file.
+     *
+     * - In macOS, it will be `/Applications/DevEco-Studio.app/Contents/tools/emulator`;
+     * - In Windows, it will be `C:\Program Files\Huawei\DevEco Studio\tools\emulator`;
+     * - In other platforms, it will be `~/.huawei/Emulator`.
+     */
+    emulatorPath?: string | vscode_uri0.URI;
+    /**
+     * The platform-specific adapters.
+     */
+    adapter?: ImageManager.Adapter;
+  }
+  interface Serializable extends BaseSerializable<ImageManager> {}
+}
+interface ImageManager extends Serializable<ImageManager.Serializable> {
   /**
-   * Architecture.
-   *
-   * @example 'arm'
+   * Get the resolved image manager options.
    */
-  'abi': string;
+  getOptions(): ResolvedImageManagerOptions;
   /**
-   * API version.
-   *
-   * @example '21'
+   * Get the operating system of the current image manager.
    */
-  'apiVersion': string;
+  getOperatingSystem(): SDKList.OS;
   /**
-   * Deployed path.
-   *
-   * @example '/Users/xxx/.Huawei/Emulator/deployed/Huawei_Wearable'
+   * Get the architecture of the current image manager.
    */
-  'path': string;
+  getArch(): SDKList.Arch;
   /**
-   * Show version.
-   *
-   * @example 'HarmonyOS 6.0.1(21)'
+   * Get local images.
    */
-  'showVersion': string;
+  getLocalImages(): Promise<LocalImage[]>;
   /**
-   * HarmonyOS version.
+   * Get remote images.
    *
-   * @example 'HarmonyOS-6.0.1'
+   * @param supportVersion - The support version of the SDK. If not provided, the default value is `6.0-hos-single-9`.
    */
-  'harmonyOSVersion'?: string;
+  getRemoteImages(supportVersion?: string): Promise<RemoteImage[] | SDKList.SDKListError>;
   /**
-   * Guest version.
+   * Get downloaded remote images.
    *
-   * @example 'HarmonyOS 6.0.1(21)'
+   * @param supportVersion - The support version of the SDK. If not provided, the default value is `6.0-hos-single-9`.
    */
-  'guestVersion'?: string;
+  getDownloadedRemoteImages(supportVersion?: string): Promise<RemoteImage[] | SDKList.SDKListError>;
   /**
-   * Cover resolution width.
-   *
-   * @example '2472'
+   * Check if the emulator is compatible with current image manager.
    */
-  'coverResolutionWidth'?: string;
+  isCompatible(): Promise<boolean>;
   /**
-   * Cover resolution height.
-   *
-   * @example '1648'
+   * Get the `lists.json` file path.
    */
-  'coverResolutionHeight'?: string;
+  getListsFilePath(): vscode_uri0.URI;
   /**
-   * Cover diagonal size.
+   * Read the `lists.json` file.
    *
-   * @example '13.0'
+   * @returns The `lists.json` file.
    */
-  'coverDiagonalSize'?: string;
+  readListsFile(): Promise<ListsFile>;
   /**
-   * HarmonyOS SDK path.
+   * Read the `emulator.json` file.
    *
-   * @example '/Applications/DevEco-Studio.app/Contents/sdk'
+   * @returns The `emulator.json` file.
    */
-  'harmonyos.sdk.path': string;
+  readEmulatorFile(): Promise<EmulatorFile>;
   /**
-   * HarmonyOS config path.
+   * Read the `product-config.json` file.
    *
-   * @example '/Users/xxx/Library/Application Support/Huawei/DevEcoStudio6.0'
+   * @returns The `product-config.json` file.
    */
-  'harmonyos.config.path': string;
+  readProductConfigFile(): Promise<ProductConfigFile>;
   /**
-   * HarmonyOS log path.
-   *
-   * @example '/Users/xxx/Library/Logs/Huawei/DevEcoStudio6.0'
+   * Get deployed devices.
    */
-  'harmonyos.log.path': string;
+  getDeployedDevices(): Promise<Device[]>;
 }
+declare function createImageManager(options: ImageManager.Options): Promise<ImageManager>;
 //#endregion
-//#region src/devices/device.d.ts
-interface Device {
-  getOptions(): Device.Options;
-  getScreen(): Screen;
-  getScreenPreset(): ScreenPreset | undefined;
-  getImage(): LocalImage;
-  setUuid(uuid: Device.UUID): this;
-  getUuid(): Device.UUID;
-  buildList(): FullDeployedImageOptions;
-  buildIni(): Record<string, string | undefined>;
-  toIniString(): string;
-  deploy(): Promise<void>;
-  delete(): Promise<void>;
-  isDeployed(): Promise<boolean>;
-  toJSON(): Device.Stringifiable;
+//#region src/common/serializable-file.d.ts
+interface SerializableFile extends Serializable<SerializableFile.Serializable>, SerializableContent<SerializableFile.Content> {
+  getImageManager(): ImageManager;
+  /** Serialize the serializable file to a string. */
+  serialize(): Promise<string>;
+  /** Write the serialized content to the file system. */
+  write(): Promise<void>;
 }
-declare namespace Device {
-  type UUID = `${string}-${string}-${string}-${string}-${string}`;
-  interface Options {
-    name: string;
-    cpuNumber: number;
-    diskSize: number;
-    memorySize: number;
-    screen: Screen | ScreenPreset;
-  }
-  interface IniOptions {
-    /** @default CN */
-    vendorCountry?: string;
-    /** @default true */
-    isPublic?: boolean;
-    /** Override the ini options. */
-    overrides?: Record<string, string | undefined>;
-  }
-  interface Stringifiable extends Omit<Options, 'screen'> {
-    list: FullDeployedImageOptions;
-    ini: Record<string, string | undefined>;
-  }
+declare namespace SerializableFile {
+  type Content = SerializableContent.Content;
+  interface Serializable extends BaseSerializable<SerializableFile> {}
+}
+//#endregion
+//#region src/configs/config-ini/config-ini.d.ts
+interface ConfigIniFile<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> extends Serializable<ConfigIniFile.Serializable>, Omit<SerializableFile, 'toJSON'> {
+  getDevice(): Device<ProductDeviceType, ProductName>;
+  getFileUri(): vscode_uri0.URI;
+}
+declare namespace ConfigIniFile {
+  type Content = Record<string, string | undefined>;
+  type GenericContent<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> = Content & {
+    productModel: ProductName;
+  };
+  interface Serializable<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> extends Omit<BaseSerializable<ConfigIniFile<ProductDeviceType, ProductName>>, 'device'> {}
+  function is(value: unknown): value is ConfigIniFile;
+}
+//#endregion
+//#region src/configs/named-ini/named-ini.d.ts
+interface NamedIniFile<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> extends Serializable<NamedIniFile.Serializable>, Omit<SerializableFile, 'toJSON'> {
+  getDevice(): Device<ProductDeviceType, ProductName>;
+  getFileUri(): vscode_uri0.URI;
+}
+declare namespace NamedIniFile {
+  type Content = Record<string, string>;
+  interface Serializable<ProductDeviceType extends ProductConfigFile.DeviceType = ProductConfigFile.DeviceType, ProductName extends ProductConfigFile.GenericContent<ProductDeviceType>['name'] = ProductConfigFile.GenericContent<ProductDeviceType>['name']> extends Omit<BaseSerializable<NamedIniFile<ProductDeviceType, ProductName>>, 'device'> {}
+  function is(value: unknown): value is NamedIniFile;
 }
 //#endregion
-export { Arch, BaseEmulatorConfigItem, type CoverScreen, DeployError, DeployedDevModel, DeployedImageConfig, DeployedImageConfigWithProductName, DeployedImageOptions, DevModel, type Device, DeviceType, type DoubleScreen, EmulatorConfig, EmulatorConfigItem, type EmulatorPreset, FullDeployedImageOptions, GroupPCAllEmulatorConfigItem, GroupPhoneAllEmulatorConfigItem, type Image, type ImageManager, type ImageManagerOptions, type ImageType, type LocalImage, OS, type OuterDoubleScreen, type OuterScreen, PCAllEmulatorConfigItem, PCAllSnakecaseDeviceType, ParentEmulatorConfigItem, ParentEmulatorSnakecaseDeviceType, PascalCaseDeviceType, PhoneAllEmulatorConfigItem, PhoneAllSnakecaseDeviceType, type ProductConfig, ProductConfigItem, ProductNameable, type ProductPreset, type RemoteImage, RequestUrlError, type Screen, type ScreenPreset, type SingleScreen, SnakecaseDeviceType, Stringifiable, createCoverScreen, createDoubleScreen, createImageManager, createOuterDoubleScreen, createOuterScreen, createScreen, createScreenPreset, createSingleScreen, isPCAllSnakecaseDeviceType, isPhoneAllSnakecaseDeviceType, version };
+export { BaseImage, BaseSerializable, ConfigIniFile, CustomizeFoldableScreen, CustomizeScreen, DeepPartial, Device, EmulatorBasicItem, EmulatorFile, EmulatorFoldItem, EmulatorGroupItem, EmulatorTripleFoldItem, type Image, type ImageManager, ListsFile, ListsFileItem, LocalImage, type NamedIniFile, ProductConfigFile, ProductConfigItem, RemoteImage, SDKList, ScreenPreset, Serializable, createImageManager };