@aiscene/core 1.1.1

package/dist/types/dump/html-utils.d.ts

@@ -0,0 +1,75 @@
+export declare const escapeContent: (html: string) => string;
+export declare const unescapeContent: (html: string) => string;
+/** Chunk size for streaming file operations (64KB) */
+export declare const STREAMING_CHUNK_SIZE: number;
+/**
+ * Callback for processing matched tags during streaming.
+ * @param content - The content between open and close tags
+ * @returns true to stop scanning, false to continue
+ */
+type TagMatchCallback = (content: string) => boolean;
+/**
+ * Stream through a file and find tags matching the pattern.
+ * Memory usage: O(chunk_size + tag_size), not O(file_size).
+ *
+ * @param filePath - Absolute path to the file
+ * @param openTag - Opening tag to search for
+ * @param closeTag - Closing tag
+ * @param onMatch - Callback for each matched tag content
+ */
+export declare function streamScanTags(filePath: string, openTag: string, closeTag: string, onMatch: TagMatchCallback): void;
+/**
+ * Synchronously extract a specific image's base64 data from an HTML file by its id.
+ * Uses streaming to avoid loading the entire file into memory.
+ *
+ * @param htmlPath - Absolute path to the HTML file
+ * @param imageId - The id of the image to extract
+ * @returns The base64 data string, or null if not found
+ */
+export declare function extractImageByIdSync(htmlPath: string, imageId: string): string | null;
+/**
+ * Stream image script tags from source file directly to output file.
+ * Memory usage: O(single_image_size), not O(all_images_size).
+ *
+ * @param srcFilePath - Source HTML file path
+ * @param destFilePath - Destination file path to append to
+ */
+export declare function streamImageScriptsToFile(srcFilePath: string, destFilePath: string): void;
+/**
+ * Extract the LAST dump script content from HTML file using streaming.
+ * Memory usage: O(dump_size), not O(file_size).
+ *
+ * @param filePath - Absolute path to the HTML file
+ * @returns The dump script content (trimmed), or empty string if not found
+ */
+export declare function extractLastDumpScriptSync(filePath: string): string;
+/**
+ * Extract ALL dump script contents from an HTML file using streaming.
+ * Each entry includes the full opening tag (for attribute extraction) and the content.
+ *
+ * @param filePath - Absolute path to the HTML file
+ * @returns Array of { openTag, content } for each dump script found
+ */
+export declare function extractAllDumpScriptsSync(filePath: string): {
+    openTag: string;
+    content: string;
+}[];
+/**
+ * Stream ALL dump scripts from an HTML file.
+ * Calls onMatch for each dump script and keeps memory bounded to a single
+ * dump script payload instead of accumulating every dump in memory.
+ *
+ * @param filePath - Absolute path to the HTML file
+ * @param onMatch - Callback for each dump script; return true to stop early
+ */
+export declare function streamDumpScriptsSync(filePath: string, onMatch: (dumpScript: {
+    openTag: string;
+    content: string;
+}) => boolean): void;
+export declare function parseImageScripts(html: string): Record<string, string>;
+export declare function parseDumpScript(html: string): string;
+export declare function parseDumpScriptAttributes(html: string): Record<string, string>;
+export declare function generateImageScriptTag(id: string, data: string): string;
+export declare function getBaseUrlFixScript(): string;
+export declare function generateDumpScriptTag(json: string, attributes?: Record<string, string | number | boolean>): string;
+export {};

package/dist/types/dump/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Dump module - utilities for HTML parsing and image restoration.
+ */
+export { restoreImageReferences } from './screenshot-restoration';
+export { escapeContent, unescapeContent, parseImageScripts, parseDumpScript, parseDumpScriptAttributes, generateImageScriptTag, generateDumpScriptTag, } from './html-utils';

package/dist/types/dump/screenshot-restoration.d.ts

@@ -0,0 +1,8 @@
+import { type ScreenshotRef } from './screenshot-store';
+/**
+ * Recursively restore image references in parsed data.
+ * Replaces ScreenshotRef with lazy
+ * { get base64() {...}, capturedAt } objects.
+ * The resolver is only called when .base64 is first accessed.
+ */
+export declare function restoreImageReferences<T>(data: T, resolveImage: (ref: ScreenshotRef) => string): T;

package/dist/types/dump/screenshot-store.d.ts

@@ -0,0 +1,49 @@
+import type { ScreenshotItem } from '../screenshot-item';
+export interface ScreenshotRef {
+    type: 'midscene_screenshot_ref';
+    id: string;
+    capturedAt: number;
+    mimeType: 'image/png' | 'image/jpeg';
+    storage: 'inline' | 'file';
+    path?: string;
+}
+export declare function normalizeScreenshotRef(value: unknown): ScreenshotRef | null;
+type ResolvedScreenshotSource = {
+    type: 'data-uri';
+    id: string;
+    mimeType: ScreenshotRef['mimeType'];
+    dataUri: string;
+} | {
+    type: 'file';
+    id: string;
+    mimeType: ScreenshotRef['mimeType'];
+    filePath: string;
+};
+export declare function resolveScreenshotSource(refInput: unknown, options: {
+    reportPath: string;
+    fallbackId?: string;
+    fallbackMimeType?: ScreenshotRef['mimeType'];
+}): ResolvedScreenshotSource;
+export declare class ScreenshotStore {
+    private readonly mode;
+    private readonly reportPath;
+    private readonly screenshotsDir?;
+    private readonly writeInlineImage?;
+    private readonly alsoWriteFileCopy;
+    private readonly writtenInlineIds;
+    private readonly writtenFileIds;
+    constructor(options: {
+        mode: 'inline' | 'directory';
+        reportPath: string;
+        screenshotsDir?: string;
+        writeInlineImage?: (id: string, base64: string) => void;
+        alsoWriteFileCopy?: boolean;
+        /** @deprecated Use alsoWriteFileCopy instead. */
+        ensureFileCopy?: boolean;
+    });
+    persist(screenshot: ScreenshotItem): ScreenshotRef;
+    private persistToSharedFileIfNeeded;
+    loadBase64(refInput: unknown): string;
+    cleanup(): void;
+}
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import Service from './service/index';
+import { TaskRunner } from './task-runner';
+import { getVersion } from './utils';
+export { plan, AiLocateElement, runConnectivityTest, getMidsceneLocationSchema, PointSchema, SizeSchema, RectSchema, TMultimodalPromptSchema, TUserPromptSchema, type TMultimodalPrompt, type TUserPrompt, type ConnectivityCheckResultItem, type ConnectivityTestConfig, type ConnectivityTestResult, } from './ai-model/index';
+export { MIDSCENE_MODEL_NAME, type CreateOpenAIClientFn, } from '@midscene/shared/env';
+export type * from './types';
+export { ServiceError, ExecutionDump, ReportActionDump, GroupedActionDump, type IExecutionDump, type IReportActionDump, type IGroupedActionDump, type ReportMeta, type GroupMeta, } from './types';
+export { z };
+export default Service;
+export { TaskRunner, Service, getVersion };
+export type { MidsceneYamlScript, MidsceneYamlTask, MidsceneYamlFlowItem, MidsceneYamlConfigResult, MidsceneYamlConfig, MidsceneYamlScriptWebEnv, MidsceneYamlScriptAndroidEnv, MidsceneYamlScriptIOSEnv, MidsceneYamlScriptEnv, LocateOption, DetailedLocateParam, } from './yaml';
+export { Agent, type AgentOpt, type AiActOptions, createAgent } from './agent';
+export { restoreImageReferences, escapeContent, unescapeContent, parseImageScripts, parseDumpScript, parseDumpScriptAttributes, generateImageScriptTag, generateDumpScriptTag, } from './dump';
+export type { IReportGenerator } from './report-generator';
+export { ReportGenerator, nullReportGenerator } from './report-generator';
+export { collectDedupedExecutions, ReportMergingTool, dedupeExecutionsKeepLatest, splitReportHtmlByExecution, } from './report';
+export { createReportCliCommands, reportFileToMarkdown, splitReportFile, type ConsumeReportFileAction, type ReportFileToMarkdownOptions, type ReportCliCommandDefinition, type ReportCliCommandEntry, type SplitReportFileOptions, } from './report-cli';
+export { ScreenshotItem } from './screenshot-item';
+export { ScreenshotStore, type ScreenshotRef } from './dump/screenshot-store';
+export { executionToMarkdown, reportToMarkdown, type ExecutionMarkdownOptions, type ExecutionMarkdownResult, type ReportMarkdownResult, type MarkdownAttachment, } from './report-markdown';

package/dist/types/report-cli.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+type ReportCliToolResult = {
+    isError: boolean;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+};
+type ReportCliSchema = Record<string, z.ZodTypeAny>;
+export interface ReportCliCommandDefinition {
+    name: string;
+    description: string;
+    schema: ReportCliSchema;
+    handler: (args: Record<string, unknown>) => Promise<ReportCliToolResult>;
+}
+export interface ReportCliCommandEntry {
+    name: string;
+    def: ReportCliCommandDefinition;
+}
+export type ConsumeReportFileAction = 'split' | 'to-markdown';
+export interface ConsumeReportFileOptions {
+    htmlPath: string;
+    outputDir: string;
+}
+export type SplitReportFileOptions = ConsumeReportFileOptions;
+export type ReportFileToMarkdownOptions = ConsumeReportFileOptions;
+export declare function splitReportFile(options: SplitReportFileOptions): {
+    executionJsonFiles: string[];
+    screenshotFiles: string[];
+};
+export declare function reportFileToMarkdown(options: ReportFileToMarkdownOptions): Promise<{
+    markdownFiles: string[];
+    screenshotFiles: string[];
+}>;
+export declare function createReportCliCommands(): ReportCliCommandEntry[];
+export {};

package/dist/types/report-generator.d.ts

@@ -0,0 +1,81 @@
+import { type ExecutionDump, ReportActionDump, type ReportAttributes, type ReportMeta } from './types';
+export interface IReportGenerator {
+    /**
+     * Write or update a single execution.
+     * Each call appends a new dump script tag. The frontend deduplicates
+     * executions with the same id/name, keeping only the last one.
+     *
+     * @param execution  Current execution's full data
+     * @param reportMeta  Report-level metadata (groupName, sdkVersion, etc.)
+     */
+    onExecutionUpdate(execution: ExecutionDump, reportMeta: ReportMeta, attributes?: ReportAttributes): void;
+    /**
+     * @deprecated Use onExecutionUpdate instead. Kept for backward compatibility.
+     */
+    onDumpUpdate?(dump: ReportActionDump): void;
+    /**
+     * Wait for all queued write operations to complete.
+     */
+    flush(): Promise<void>;
+    /**
+     * Finalize the report. Calls flush() internally.
+     */
+    finalize(): Promise<string | undefined>;
+    getReportPath(): string | undefined;
+}
+export declare const nullReportGenerator: IReportGenerator;
+export declare function assertReportGenerationOptions(opts: {
+    generateReport?: boolean;
+    persistExecutionDump?: boolean;
+}): void;
+export declare class ReportGenerator implements IReportGenerator {
+    private reportPath;
+    private screenshotMode;
+    private shouldPersistExecutionDump;
+    private autoPrint;
+    private firstWriteDone;
+    private executionLogIndex;
+    private executionLogFileIndexByExecutionKey;
+    private readonly reportStreamId;
+    private screenshotStore;
+    private initialized;
+    private lastExecution?;
+    private lastReportMeta?;
+    private reportAttributes;
+    private writeQueue;
+    private destroyed;
+    constructor(options: {
+        reportPath: string;
+        screenshotMode: 'inline' | 'directory';
+        persistExecutionDump?: boolean;
+        autoPrint?: boolean;
+    });
+    static create(reportFileName: string, opts: {
+        generateReport?: boolean;
+        persistExecutionDump?: boolean;
+        outputFormat?: 'single-html' | 'html-and-external-assets';
+        autoPrintReportMsg?: boolean;
+    }): IReportGenerator;
+    onExecutionUpdate(execution: ExecutionDump, reportMeta: ReportMeta, attributes?: ReportAttributes): void;
+    flush(): Promise<void>;
+    finalize(): Promise<string | undefined>;
+    getReportPath(): string | undefined;
+    private printReportPath;
+    private doWriteExecution;
+    private mergeReportAttributes;
+    private hydrateStateFromExistingReport;
+    private getDumpScriptAttributes;
+    /**
+     * Wrap an ExecutionDump + ReportMeta into a single-execution ReportActionDump.
+     */
+    private wrapAsReportDump;
+    /**
+     * Append-only inline mode: write new screenshots and a dump tag on every call.
+     * The frontend deduplicates executions with the same id/name (keeps last).
+     * Duplicate dump JSON is acceptable; only screenshots are deduplicated.
+     */
+    private writeInlineExecution;
+    private writeDirectoryExecution;
+    private getExecutionLogKey;
+    private persistExecutionDumpToFile;
+}

package/dist/types/report-markdown.d.ts

@@ -0,0 +1,24 @@
+import type { ExecutionDump, IExecutionDump, IReportActionDump, ReportActionDump } from './types';
+export interface MarkdownAttachment {
+    id: string;
+    suggestedFileName: string;
+    mimeType?: string;
+    filePath: string;
+    executionIndex: number;
+    taskIndex: number;
+    /** Populated when screenshot data is available in memory (e.g. browser context). */
+    base64Data?: string;
+}
+export interface ExecutionMarkdownOptions {
+    screenshotBaseDir?: string;
+}
+export interface ExecutionMarkdownResult {
+    markdown: string;
+    attachments: MarkdownAttachment[];
+}
+export interface ReportMarkdownResult {
+    markdown: string;
+    attachments: MarkdownAttachment[];
+}
+export declare function executionToMarkdown(execution: ExecutionDump | IExecutionDump, options?: ExecutionMarkdownOptions): ExecutionMarkdownResult;
+export declare function reportToMarkdown(report: ReportActionDump | IReportActionDump): ReportMarkdownResult;

package/dist/types/report.d.ts

@@ -0,0 +1,52 @@
+import { type ExecutionDump, type IExecutionDump, ReportActionDump } from './types';
+import type { ReportFileWithAttributes } from './types';
+/**
+ * Check if a report is in directory mode (html-and-external-assets).
+ * Directory mode reports: {name}/index.html + {name}/screenshots/
+ */
+export declare function isDirectoryModeReport(reportFilePath: string): boolean;
+/**
+ * Deduplicate executions by stable id, keeping only the last occurrence.
+ * Old-format executions without id are always preserved.
+ */
+export declare function dedupeExecutionsKeepLatest<T extends Pick<ExecutionDump, 'id'>>(executions: T[]): T[];
+export declare class ReportMergingTool {
+    private reportInfos;
+    private createEmptyDumpString;
+    append(reportInfo: ReportFileWithAttributes): void;
+    clear(): void;
+    /**
+     * Merge multiple dump script contents (from the same source report)
+     * into a single serialized ReportActionDump string.
+     * If there's only one dump, return it as-is. If multiple, merge
+     * all executions into the first dump's group structure.
+     */
+    private mergeDumpScripts;
+    mergeReports(reportFileName?: 'AUTO' | string, opts?: {
+        rmOriginalReports?: boolean;
+        overwrite?: boolean;
+    }): string | null;
+}
+export interface SplitReportHtmlOptions {
+    htmlPath: string;
+    outputDir: string;
+}
+export interface SplitReportHtmlResult {
+    executionJsonFiles: string[];
+    screenshotFiles: string[];
+}
+export interface CollectedReportExecutions {
+    baseDump: ReportActionDump;
+    executions: IExecutionDump[];
+}
+/**
+ * Collect executions from a report HTML, deduplicating by stable id while
+ * keeping only the latest occurrence. Old-format executions without id are
+ * always preserved.
+ */
+export declare function collectDedupedExecutions(htmlPath: string): CollectedReportExecutions;
+/**
+ * Reverse parse a Midscene report HTML into per-execution JSON files and
+ * externalized screenshots.
+ */
+export declare function splitReportHtmlByExecution(options: SplitReportHtmlOptions): SplitReportHtmlResult;

package/dist/types/screenshot-item.d.ts

@@ -0,0 +1,67 @@
+import { type ScreenshotRef } from './dump/screenshot-store';
+/**
+ * Serialization format for ScreenshotItem
+ * - { $screenshot: "id" } - inline mode, references imageMap in HTML
+ * - { base64: "path" } - directory mode, references external file path
+ */
+export type ScreenshotSerializeFormat = ScreenshotRef;
+/**
+ * ScreenshotItem encapsulates screenshot data.
+ *
+ * Supports lazy loading after memory release:
+ * - inline mode: reads from HTML file using streaming (extractImageByIdSync)
+ * - directory mode: reads from file on disk
+ *
+ * After persistence, memory is released but the screenshot can be recovered
+ * on-demand from disk, making it safe to release memory at any time.
+ */
+export declare class ScreenshotItem {
+    private _id;
+    private _base64;
+    private _format;
+    private _capturedAt;
+    private _serializedRef;
+    private _persistedPath;
+    private _persistedHtmlPath;
+    private constructor();
+    /** Create a new ScreenshotItem from base64 data */
+    static create(base64: string, capturedAt: number): ScreenshotItem;
+    get id(): string;
+    /** Get the image format (png or jpeg) */
+    get format(): 'png' | 'jpeg';
+    /** Get the file extension for this screenshot */
+    get extension(): string;
+    /** Get screenshot capture timestamp in milliseconds */
+    get capturedAt(): number;
+    get base64(): string;
+    /** Check if base64 data is still available in memory (not yet released) */
+    hasBase64(): boolean;
+    /**
+     * Mark as persisted to HTML (inline mode).
+     * Releases base64 memory, but keeps HTML path for lazy loading recovery.
+     * @param htmlPath - absolute path to the HTML file containing the image
+     */
+    markPersistedInline(htmlPath: string): ScreenshotRef;
+    /**
+     * Register a file-backed recovery path without changing the serialized mode.
+     * Used when inline persistence also needs a shared file copy next to dumps.
+     */
+    registerPersistedFileCopy(relativePath: string, absolutePath: string): ScreenshotRef;
+    /**
+     * Mark as persisted to file (directory mode).
+     * Releases base64 memory, but keeps file path for lazy loading recovery.
+     * @param relativePath - relative path for serialization (e.g., "./screenshots/id.jpeg")
+     * @param absolutePath - absolute path for lazy loading recovery
+     */
+    markPersistedToPath(relativePath: string, absolutePath: string): ScreenshotRef;
+    /** Serialize for JSON - format depends on persistence state */
+    toSerializable(): ScreenshotSerializeFormat;
+    /** Check if a value is a serialized ScreenshotItem reference (inline or directory mode) */
+    static isSerialized(value: unknown): value is ScreenshotSerializeFormat;
+    private createRef;
+    /**
+     * Get base64 data without the data URI prefix.
+     * Useful for writing raw binary data to files.
+     */
+    get rawBase64(): string;
+}

package/dist/types/service/index.d.ts

@@ -0,0 +1,24 @@
+import type { AIDescribeElementResponse, LocateResultElement, LocateResultWithDump, PlanningLocateParam, Rect, ServiceExtractOption, ServiceExtractParam, ServiceExtractResult, ServiceTaskInfo, UIContext } from '../types';
+import type { IModelConfig } from '@midscene/shared/env';
+import type { TMultimodalPrompt } from '../common';
+export interface LocateOpts {
+    context?: UIContext;
+    planLocatedElement?: LocateResultElement;
+}
+export type AnyValue<T> = {
+    [K in keyof T]: unknown extends T[K] ? any : T[K];
+};
+interface ServiceOptions {
+    taskInfo?: Omit<ServiceTaskInfo, 'durationMs'>;
+}
+export default class Service {
+    contextRetrieverFn: () => Promise<UIContext> | UIContext;
+    taskInfo?: Omit<ServiceTaskInfo, 'durationMs'>;
+    constructor(context: UIContext | (() => Promise<UIContext> | UIContext), opt?: ServiceOptions);
+    locate(query: PlanningLocateParam, opt: LocateOpts, modelConfig: IModelConfig, abortSignal?: AbortSignal): Promise<LocateResultWithDump>;
+    extract<T>(dataDemand: ServiceExtractParam, modelConfig: IModelConfig, opt?: ServiceExtractOption, pageDescription?: string, multimodalPrompt?: TMultimodalPrompt, context?: UIContext): Promise<ServiceExtractResult<T>>;
+    describe(target: Rect | [number, number], modelConfig: IModelConfig, opt?: {
+        deepLocate?: boolean;
+    }): Promise<Pick<AIDescribeElementResponse, 'description'>>;
+}
+export {};

package/dist/types/service/utils.d.ts

@@ -0,0 +1,2 @@
+import type { PartialServiceDumpFromSDK, ServiceDump } from '../types';
+export declare function createServiceDump(data: PartialServiceDumpFromSDK): ServiceDump;

package/dist/types/skill/index.d.ts

@@ -0,0 +1,25 @@
+import type { AbstractInterface } from '../device';
+type DeviceClass = new (...args: any[]) => AbstractInterface;
+export interface SkillCLIOptions {
+    scriptName: string;
+    DeviceClass: DeviceClass;
+}
+/**
+ * Launch a Skill CLI for a custom interface Device class.
+ * This enables AI coding assistants (Claude Code, Cline, etc.) to control
+ * your custom interface through CLI commands.
+ *
+ * @example
+ * ```typescript
+ * #!/usr/bin/env node
+ * import { runSkillCLI } from '@midscene/core/skill';
+ * import { SampleDevice } from './sample-device';
+ *
+ * runSkillCLI({
+ *   DeviceClass: SampleDevice,
+ *   scriptName: 'my-device',
+ * });
+ * ```
+ */
+export declare function runSkillCLI(options: SkillCLIOptions): Promise<void>;
+export {};

package/dist/types/task-runner.d.ts

@@ -0,0 +1,50 @@
+import { ExecutionDump, type ExecutionTask, type ExecutionTaskApply, type ExecutionTaskProgressOptions, type UIContext } from './types';
+type TaskRunnerInitOptions = ExecutionTaskProgressOptions & {
+    tasks?: ExecutionTaskApply[];
+    onTaskUpdate?: (runner: TaskRunner, error?: TaskExecutionError) => Promise<void> | void;
+};
+type TaskRunnerOperationOptions = {
+    allowWhenError?: boolean;
+};
+export declare class TaskRunner {
+    readonly id: string;
+    name: string;
+    tasks: ExecutionTask[];
+    status: 'init' | 'pending' | 'running' | 'completed' | 'error';
+    onTaskStart?: ExecutionTaskProgressOptions['onTaskStart'];
+    private readonly uiContextBuilder;
+    private readonly onTaskUpdate?;
+    private readonly executionLogTime;
+    constructor(name: string, uiContextBuilder: () => Promise<UIContext>, options?: TaskRunnerInitOptions);
+    private emitOnTaskUpdate;
+    private lastUiContext?;
+    private getUiContext;
+    private captureScreenshot;
+    private attachRecorderItem;
+    private markTaskAsPending;
+    private normalizeStatusFromError;
+    append(task: ExecutionTaskApply[] | ExecutionTaskApply, options?: TaskRunnerOperationOptions): Promise<void>;
+    appendAndFlush(task: ExecutionTaskApply[] | ExecutionTaskApply, options?: TaskRunnerOperationOptions): Promise<{
+        output: any;
+        thought?: string;
+    } | undefined>;
+    flush(options?: TaskRunnerOperationOptions): Promise<{
+        output: any;
+        thought?: string;
+    } | undefined>;
+    isInErrorState(): boolean;
+    latestErrorTask(): ExecutionTask | null;
+    dump(): ExecutionDump;
+    appendErrorPlan(errorMsg: string): Promise<{
+        output: undefined;
+        runner: TaskRunner;
+    }>;
+}
+export declare class TaskExecutionError extends Error {
+    runner: TaskRunner;
+    errorTask: ExecutionTask | null;
+    constructor(message: string, runner: TaskRunner, errorTask: ExecutionTask | null, options?: {
+        cause?: unknown;
+    });
+}
+export {};

package/dist/types/task-timing.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutionTask } from './types';
+type ExecutionTaskTiming = NonNullable<ExecutionTask['timing']>;
+type NumericTimingField = {
+    [K in keyof ExecutionTaskTiming]-?: ExecutionTaskTiming[K] extends number | undefined ? K : never;
+}[keyof ExecutionTaskTiming];
+export type TimingSettableField = Exclude<NumericTimingField, 'start' | 'end' | 'cost'>;
+export declare function setTimingFieldOnce(timing: ExecutionTaskTiming | undefined, field: TimingSettableField): void;
+export {};

package/dist/types/tree.d.ts

@@ -0,0 +1,4 @@
+import type { BaseElement, ElementTreeNode } from '@midscene/shared/types';
+import { trimAttributes, truncateText } from '@midscene/shared/extractor';
+export { trimAttributes, truncateText };
+export declare function descriptionOfTree<ElementType extends BaseElement = BaseElement>(tree: ElementTreeNode<ElementType>, truncateTextLength?: number, filterNonTextContent?: boolean, visibleOnly?: boolean): string;