@midscene/core 0.26.5-beta-20250814080504.0 → 0.26.5-beta-20250814125155.0

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

@@ -0,0 +1,26 @@
+import { callAiFn } from '../ai-model/common';
+import type { AIDescribeElementResponse, AIElementResponse, AIUsageInfo, BaseElement, DetailedLocateParam, DumpSubscriber, InsightAction, InsightAssertionResponse, InsightExtractOption, InsightExtractParam, InsightOptions, InsightTaskInfo, LocateResult, Rect, TMultimodalPrompt, TUserPrompt, UIContext } from '../types';
+export interface LocateOpts {
+    context?: UIContext<BaseElement>;
+    callAI?: typeof callAiFn<AIElementResponse>;
+}
+export type AnyValue<T> = {
+    [K in keyof T]: unknown extends T[K] ? any : T[K];
+};
+export default class Insight<ElementType extends BaseElement = BaseElement, ContextType extends UIContext<ElementType> = UIContext<ElementType>> {
+    contextRetrieverFn: (action: InsightAction) => Promise<ContextType> | ContextType;
+    aiVendorFn: (...args: Array<any>) => Promise<any>;
+    onceDumpUpdatedFn?: DumpSubscriber;
+    taskInfo?: Omit<InsightTaskInfo, 'durationMs'>;
+    constructor(context: ContextType | ((action: InsightAction) => Promise<ContextType> | ContextType), opt?: InsightOptions);
+    locate(query: DetailedLocateParam, opt?: LocateOpts): Promise<LocateResult>;
+    extract<T>(dataDemand: InsightExtractParam, opt?: InsightExtractOption, multimodalPrompt?: TMultimodalPrompt): Promise<{
+        data: T;
+        thought?: string;
+        usage?: AIUsageInfo;
+    }>;
+    assert(assertion: TUserPrompt): Promise<InsightAssertionResponse>;
+    describe(target: Rect | [number, number], opt?: {
+        deepThink?: boolean;
+    }): Promise<Pick<AIDescribeElementResponse, 'description'>>;
+}

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

@@ -0,0 +1,2 @@
+import type { DumpSubscriber, PartialInsightDumpFromSDK } from '../types';
+export declare function emitInsightDump(data: PartialInsightDumpFromSDK, dumpSubscriber?: DumpSubscriber): void;

package/dist/types/tree.d.ts

@@ -1,11 +1 @@
-import { descriptionOfTree } from '@midscene/shared/extractor';
-import { trimAttributes } from '@midscene/shared/extractor';
-import { truncateText } from '@midscene/shared/extractor';
-
-export { descriptionOfTree }
-
-export { trimAttributes }
-
-export { truncateText }
-
-export { }
+export { truncateText, trimAttributes, descriptionOfTree, } from '@midscene/shared/extractor';

package/dist/types/types.d.ts

@@ -0,0 +1,399 @@
+import type { NodeType } from '@midscene/shared/constants';
+import type { BaseElement, ElementTreeNode, Rect, Size } from '@midscene/shared/types';
+import type { ChatCompletionMessageParam } from 'openai/resources/index';
+import type { DetailedLocateParam, MidsceneYamlFlowItem } from './yaml';
+export type { ElementTreeNode, BaseElement, Rect, Size, Point, } from '@midscene/shared/types';
+export * from './yaml';
+export type AIUsageInfo = Record<string, any> & {
+    prompt_tokens: number | undefined;
+    completion_tokens: number | undefined;
+    total_tokens: number | undefined;
+    time_cost: number | undefined;
+};
+/**
+ * openai
+ *
+ */
+export declare enum AIResponseFormat {
+    JSON = "json_object",
+    TEXT = "text"
+}
+export type AISingleElementResponseById = {
+    id: string;
+    reason?: string;
+    text?: string;
+    xpaths?: string[];
+};
+export type AISingleElementResponseByPosition = {
+    position?: {
+        x: number;
+        y: number;
+    };
+    bbox?: [number, number, number, number];
+    reason: string;
+    text: string;
+};
+export type AISingleElementResponse = AISingleElementResponseById;
+export interface AIElementLocatorResponse {
+    elements: {
+        id: string;
+        reason?: string;
+        text?: string;
+        xpaths?: string[];
+    }[];
+    bbox?: [number, number, number, number];
+    isOrderSensitive?: boolean;
+    errors?: string[];
+}
+export interface AIElementCoordinatesResponse {
+    bbox: [number, number, number, number];
+    isOrderSensitive?: boolean;
+    errors?: string[];
+}
+export type AIElementResponse = AIElementLocatorResponse | AIElementCoordinatesResponse;
+export interface AIDataExtractionResponse<DataDemand> {
+    data: DataDemand;
+    errors?: string[];
+    thought?: string;
+}
+export interface AISectionLocatorResponse {
+    bbox: [number, number, number, number];
+    references_bbox?: [number, number, number, number][];
+    error?: string;
+}
+export interface AIAssertionResponse {
+    pass: boolean;
+    thought: string;
+}
+export interface AIDescribeElementResponse {
+    description: string;
+    error?: string;
+}
+export interface LocatorValidatorOption {
+    centerDistanceThreshold?: number;
+}
+export interface LocateValidatorResult {
+    pass: boolean;
+    rect: Rect;
+    center: [number, number];
+    centerDistance?: number;
+}
+export interface AgentDescribeElementAtPointResult {
+    prompt: string;
+    deepThink: boolean;
+    verifyResult?: LocateValidatorResult;
+}
+/**
+ * context
+ */
+export declare abstract class UIContext<ElementType extends BaseElement = BaseElement> {
+    abstract screenshotBase64: string;
+    abstract tree: ElementTreeNode<ElementType>;
+    abstract size: Size;
+}
+/**
+ * insight
+ */
+export type CallAIFn = <T>(messages: ChatCompletionMessageParam[]) => Promise<T>;
+export interface InsightOptions {
+    taskInfo?: Omit<InsightTaskInfo, 'durationMs'>;
+    aiVendorFn?: CallAIFn;
+}
+export type EnsureObject<T> = {
+    [K in keyof T]: any;
+};
+export type InsightAction = 'locate' | 'extract' | 'assert' | 'describe';
+export type InsightExtractParam = string | Record<string, string>;
+export type LocateResultElement = {
+    id: string;
+    indexId?: number;
+    center: [number, number];
+    rect: Rect;
+    xpaths: string[];
+    attributes: {
+        nodeType: NodeType;
+        [key: string]: string;
+    };
+    isOrderSensitive?: boolean;
+};
+export interface LocateResult {
+    element: LocateResultElement | null;
+    rect?: Rect;
+}
+export interface InsightTaskInfo {
+    durationMs: number;
+    formatResponse?: string;
+    rawResponse?: string;
+    usage?: AIUsageInfo;
+    searchArea?: Rect;
+    searchAreaRawResponse?: string;
+    searchAreaUsage?: AIUsageInfo;
+}
+export interface DumpMeta {
+    sdkVersion: string;
+    logTime: number;
+    model_name: string;
+    model_description?: string;
+}
+export interface ReportDumpWithAttributes {
+    dumpString: string;
+    attributes?: Record<string, any>;
+}
+export interface InsightDump extends DumpMeta {
+    type: 'locate' | 'extract' | 'assert';
+    logId: string;
+    userQuery: {
+        element?: TUserPrompt;
+        dataDemand?: InsightExtractParam;
+        assertion?: TUserPrompt;
+    };
+    matchedElement: BaseElement[];
+    matchedRect?: Rect;
+    deepThink?: boolean;
+    data: any;
+    assertionPass?: boolean;
+    assertionThought?: string;
+    taskInfo: InsightTaskInfo;
+    error?: string;
+    output?: any;
+}
+export type PartialInsightDumpFromSDK = Omit<InsightDump, 'sdkVersion' | 'logTime' | 'logId' | 'model_name'>;
+export type DumpSubscriber = (dump: InsightDump) => Promise<void> | void;
+export interface LiteUISection {
+    name: string;
+    description: string;
+    sectionCharacteristics: string;
+    textIds: string[];
+}
+export type ElementById = (id: string) => BaseElement | null;
+export type InsightAssertionResponse = AIAssertionResponse & {
+    usage?: AIUsageInfo;
+};
+/**
+ * agent
+ */
+export type OnTaskStartTip = (tip: string) => Promise<void> | void;
+export interface AgentWaitForOpt {
+    checkIntervalMs?: number;
+    timeoutMs?: number;
+}
+export interface AgentAssertOpt {
+    keepRawResponse?: boolean;
+}
+/**
+ * planning
+ *
+ */
+export interface PlanningLocateParam extends DetailedLocateParam {
+    id?: string;
+    bbox?: [number, number, number, number];
+}
+export interface PlanningAction<ParamType = any> {
+    thought?: string;
+    type: 'Locate' | 'Tap' | 'RightClick' | 'Hover' | 'Drag' | 'Input' | 'KeyboardPress' | 'Scroll' | 'Error' | 'Assert' | 'AssertWithoutThrow' | 'Sleep' | 'Finished' | 'AndroidBackButton' | 'AndroidHomeButton' | 'AndroidRecentAppsButton' | 'AndroidLongPress' | 'AndroidPull';
+    param: ParamType;
+    locate?: PlanningLocateParam | null;
+}
+export interface PlanningAIResponse {
+    action?: PlanningAction;
+    actions?: PlanningAction[];
+    more_actions_needed_by_instruction: boolean;
+    log: string;
+    sleep?: number;
+    error?: string;
+    usage?: AIUsageInfo;
+    rawResponse?: string;
+    yamlFlow?: MidsceneYamlFlowItem[];
+    yamlString?: string;
+}
+export type PlanningActionParamTap = null;
+export type PlanningActionParamHover = null;
+export type PlanningActionParamRightClick = null;
+export interface PlanningActionParamInputOrKeyPress {
+    value: string;
+    autoDismissKeyboard?: boolean;
+}
+export interface PlanningActionParamAssert {
+    assertion: TUserPrompt;
+}
+export interface PlanningActionParamSleep {
+    timeMs: number;
+}
+export interface PlanningActionParamError {
+    thought: string;
+}
+export type PlanningActionParamWaitFor = AgentWaitForOpt & {
+    assertion: string;
+};
+export interface AndroidLongPressParam {
+    duration?: number;
+}
+export interface AndroidPullParam {
+    direction: 'up' | 'down';
+    distance?: number;
+    duration?: number;
+}
+/**
+ * misc
+ */
+export interface Color {
+    name: string;
+    hex: string;
+}
+export interface BaseAgentParserOpt {
+    selector?: string;
+    ignoreMarker?: boolean;
+}
+export interface PuppeteerParserOpt extends BaseAgentParserOpt {
+}
+export interface PlaywrightParserOpt extends BaseAgentParserOpt {
+}
+export interface ExecutionTaskProgressOptions {
+    onTaskStart?: (task: ExecutionTask) => Promise<void> | void;
+}
+export interface ExecutionRecorderItem {
+    type: 'screenshot';
+    ts: number;
+    screenshot?: string;
+    timing?: string;
+}
+export type ExecutionTaskType = 'Planning' | 'Insight' | 'Action' | 'Assertion' | 'Log';
+export interface ExecutorContext {
+    task: ExecutionTask;
+    element?: LocateResultElement | null;
+}
+export interface ExecutionTaskApply<Type extends ExecutionTaskType = any, TaskParam = any, TaskOutput = any, TaskLog = any> {
+    type: Type;
+    subType?: string;
+    param?: TaskParam;
+    thought?: string;
+    locate?: PlanningLocateParam | null;
+    pageContext?: UIContext;
+    executor: (param: TaskParam, context: ExecutorContext) => Promise<ExecutionTaskReturn<TaskOutput, TaskLog> | undefined | void> | undefined | void;
+}
+export interface ExecutionTaskHitBy {
+    from: string;
+    context: Record<string, any>;
+}
+export interface ExecutionTaskReturn<TaskOutput = unknown, TaskLog = unknown> {
+    output?: TaskOutput;
+    log?: TaskLog;
+    recorder?: ExecutionRecorderItem[];
+    hitBy?: ExecutionTaskHitBy;
+}
+export type ExecutionTask<E extends ExecutionTaskApply<any, any, any> = ExecutionTaskApply<any, any, any>> = E & ExecutionTaskReturn<E extends ExecutionTaskApply<any, any, infer TaskOutput, any> ? TaskOutput : unknown, E extends ExecutionTaskApply<any, any, any, infer TaskLog> ? TaskLog : unknown> & {
+    status: 'pending' | 'running' | 'finished' | 'failed' | 'cancelled';
+    error?: Error;
+    errorMessage?: string;
+    errorStack?: string;
+    timing?: {
+        start: number;
+        end?: number;
+        cost?: number;
+    };
+    usage?: AIUsageInfo;
+};
+export interface ExecutionDump extends DumpMeta {
+    name: string;
+    description?: string;
+    tasks: ExecutionTask[];
+}
+export type ExecutionTaskInsightLocateParam = PlanningLocateParam;
+export interface ExecutionTaskInsightLocateOutput {
+    element: LocateResultElement | null;
+}
+export interface ExecutionTaskInsightDumpLog {
+    dump?: InsightDump;
+}
+export type ExecutionTaskInsightLocateApply = ExecutionTaskApply<'Insight', ExecutionTaskInsightLocateParam, ExecutionTaskInsightLocateOutput, ExecutionTaskInsightDumpLog>;
+export type ExecutionTaskInsightLocate = ExecutionTask<ExecutionTaskInsightLocateApply>;
+export interface ExecutionTaskInsightQueryParam {
+    dataDemand: InsightExtractParam;
+}
+export interface ExecutionTaskInsightQueryOutput {
+    data: any;
+}
+export type ExecutionTaskInsightQueryApply = ExecutionTaskApply<'Insight', ExecutionTaskInsightQueryParam, any, ExecutionTaskInsightDumpLog>;
+export type ExecutionTaskInsightQuery = ExecutionTask<ExecutionTaskInsightQueryApply>;
+export interface ExecutionTaskInsightAssertionParam {
+    assertion: string;
+}
+export type ExecutionTaskInsightAssertionApply = ExecutionTaskApply<'Insight', ExecutionTaskInsightAssertionParam, InsightAssertionResponse, ExecutionTaskInsightDumpLog>;
+export type ExecutionTaskInsightAssertion = ExecutionTask<ExecutionTaskInsightAssertionApply>;
+export type ExecutionTaskActionApply<ActionParam = any> = ExecutionTaskApply<'Action', ActionParam, void, void>;
+export type ExecutionTaskAction = ExecutionTask<ExecutionTaskActionApply>;
+export type ExecutionTaskLogApply<LogParam = {
+    content: string;
+}> = ExecutionTaskApply<'Log', LogParam, void, void>;
+export type ExecutionTaskLog = ExecutionTask<ExecutionTaskLogApply>;
+export type ExecutionTaskPlanningApply = ExecutionTaskApply<'Planning', {
+    userInstruction: string;
+    log?: string;
+}, PlanningAIResponse>;
+export type ExecutionTaskPlanning = ExecutionTask<ExecutionTaskPlanningApply>;
+export interface GroupedActionDump {
+    groupName: string;
+    groupDescription?: string;
+    executions: ExecutionDump[];
+}
+export type PageType = 'puppeteer' | 'playwright' | 'static' | 'chrome-extension-proxy' | 'android';
+export interface StreamingCodeGenerationOptions {
+    /** Whether to enable streaming output */
+    stream?: boolean;
+    /** Callback function to handle streaming chunks */
+    onChunk?: StreamingCallback;
+    /** Callback function to handle streaming completion */
+    onComplete?: (finalCode: string) => void;
+    /** Callback function to handle streaming errors */
+    onError?: (error: Error) => void;
+}
+export type StreamingCallback = (chunk: CodeGenerationChunk) => void;
+export interface CodeGenerationChunk {
+    /** The incremental content chunk */
+    content: string;
+    /** The reasoning content */
+    reasoning_content: string;
+    /** The accumulated content so far */
+    accumulated: string;
+    /** Whether this is the final chunk */
+    isComplete: boolean;
+    /** Token usage information if available */
+    usage?: AIUsageInfo;
+}
+export interface StreamingAIResponse {
+    /** The final accumulated content */
+    content: string;
+    /** Token usage information */
+    usage?: AIUsageInfo;
+    /** Whether the response was streamed */
+    isStreamed: boolean;
+}
+export type TMultimodalPrompt = {
+    /**
+     * Support use image to inspect elements.
+     * The "images" field is an object that uses image name as key and image url as value.
+     * The image url can be a local path, a http link , or a base64 string.
+     */
+    images?: {
+        name: string;
+        url: string;
+    }[];
+    /**
+     * By default, the image url in the "images" filed starts with `https://` or `http://` will be directly sent to the LLM.
+     * In case the images are not accessible to the LLM (One common case is that image url is internal network only.), you can enable this option.
+     * Then image will be download and convert to base64 format.
+     */
+    convertHttpImage2Base64?: boolean;
+};
+export type TUserPrompt = string | ({
+    prompt: string;
+} & Partial<TMultimodalPrompt>);
+export interface DeviceAction<ParamType = any> {
+    name: string;
+    description?: string;
+    paramSchema?: string;
+    paramDescription?: string;
+    location?: 'required' | 'optional' | false;
+    whatToLocate?: string;
+    call: (context: ExecutorContext, param: ParamType) => Promise<void> | void;
+}

package/dist/types/utils.d.ts

@@ -1,47 +1,27 @@
-import { Rect } from '@midscene/shared/types';
-
-export declare function getTmpDir(): string | null;
-
-export declare function getTmpFile(fileExtWithoutDot: string): string | null;
-
-export declare function getVersion(): string;
-
-export declare const groupedActionDumpFileExt = "web-dump.json";
-
-/**
- * high performance, insert script before </html> in HTML file
- * only truncate and append, no temporary file
- */
-export declare function insertScriptBeforeClosingHtml(filePath: string, scriptContent: string): void;
-
-export declare function overlapped(container: Rect, target: Rect): boolean;
-
-export declare function replacerForPageObject(key: string, value: any): any;
-
-declare interface ReportDumpWithAttributes {
-    dumpString: string;
-    attributes?: Record<string, any>;
-}
-
-export declare function reportHTMLContent(dumpData: string | ReportDumpWithAttributes, reportPath?: string, appendReport?: boolean): string;
-
-export declare function sleep(ms: number): Promise<unknown>;
-
-export declare function stringifyDumpData(data: any, indents?: number): string;
-
-export declare function uploadTestInfoToServer({ testUrl }: {
-    testUrl: string;
-}): void;
-
-export declare function writeDumpReport(fileName: string, dumpData: string | ReportDumpWithAttributes, appendReport?: boolean): string | null;
-
-export declare function writeLogFile(opts: {
-    fileName: string;
-    fileExt: string;
-    fileContent: string;
-    type: 'dump' | 'cache' | 'report' | 'tmp';
-    generateReport?: boolean;
-    appendReport?: boolean;
-}): string | null;
-
-export { }
+import type { Rect, ReportDumpWithAttributes } from './types';
+export declare const groupedActionDumpFileExt = "web-dump.json";
+/**
+ * high performance, insert script before </html> in HTML file
+ * only truncate and append, no temporary file
+ */
+export declare function insertScriptBeforeClosingHtml(filePath: string, scriptContent: string): void;
+export declare function reportHTMLContent(dumpData: string | ReportDumpWithAttributes, reportPath?: string, appendReport?: boolean): string;
+export declare function writeDumpReport(fileName: string, dumpData: string | ReportDumpWithAttributes, appendReport?: boolean): string | null;
+export declare function writeLogFile(opts: {
+    fileName: string;
+    fileExt: string;
+    fileContent: string;
+    type: 'dump' | 'cache' | 'report' | 'tmp';
+    generateReport?: boolean;
+    appendReport?: boolean;
+}): string | null;
+export declare function getTmpDir(): string | null;
+export declare function getTmpFile(fileExtWithoutDot: string): string | null;
+export declare function overlapped(container: Rect, target: Rect): boolean;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function replacerForPageObject(key: string, value: any): any;
+export declare function stringifyDumpData(data: any, indents?: number): string;
+export declare function getVersion(): string;
+export declare function uploadTestInfoToServer({ testUrl }: {
+    testUrl: string;
+}): void;

package/dist/types/yaml.d.ts

@@ -0,0 +1,172 @@
+import type { Rect, TUserPrompt } from './types';
+import type { BaseElement, UIContext } from './types';
+export interface LocateOption {
+    deepThink?: boolean;
+    cacheable?: boolean;
+    xpath?: string;
+    pageContext?: UIContext<BaseElement>;
+}
+export interface InsightExtractOption {
+    domIncluded?: boolean | 'visible-only';
+    screenshotIncluded?: boolean;
+    returnThought?: boolean;
+}
+export interface ReferenceImage {
+    base64: string;
+    rect?: Rect;
+}
+export interface DetailedLocateParam extends LocateOption {
+    prompt: TUserPrompt;
+    referenceImage?: ReferenceImage;
+}
+export interface ScrollParam {
+    direction: 'down' | 'up' | 'right' | 'left';
+    scrollType: 'once' | 'untilBottom' | 'untilTop' | 'untilRight' | 'untilLeft';
+    distance?: null | number;
+}
+export interface MidsceneYamlScript {
+    target?: MidsceneYamlScriptWebEnv;
+    web?: MidsceneYamlScriptWebEnv;
+    android?: MidsceneYamlScriptAndroidEnv;
+    tasks: MidsceneYamlTask[];
+}
+export interface MidsceneYamlTask {
+    name: string;
+    flow: MidsceneYamlFlowItem[];
+    continueOnError?: boolean;
+}
+export interface MidsceneYamlScriptEnvBase {
+    output?: string;
+    unstableLogContent?: boolean | string;
+    aiActionContext?: string;
+}
+export interface MidsceneYamlScriptWebEnv extends MidsceneYamlScriptEnvBase {
+    serve?: string;
+    url: string;
+    userAgent?: string;
+    acceptInsecureCerts?: boolean;
+    viewportWidth?: number;
+    viewportHeight?: number;
+    viewportScale?: number;
+    waitForNetworkIdle?: {
+        timeout?: number;
+        continueOnNetworkIdleError?: boolean;
+    };
+    cookie?: string;
+    forceSameTabNavigation?: boolean;
+    bridgeMode?: false | 'newTabWithUrl' | 'currentTab';
+    closeNewTabsAfterDisconnect?: boolean;
+}
+export interface MidsceneYamlScriptAndroidEnv extends MidsceneYamlScriptEnvBase {
+    deviceId?: string;
+    launch?: string;
+}
+export type MidsceneYamlScriptEnv = MidsceneYamlScriptWebEnv | MidsceneYamlScriptAndroidEnv;
+export interface MidsceneYamlFlowItemAIAction {
+    ai?: string;
+    aiAction?: string;
+    aiActionProgressTips?: string[];
+    cacheable?: boolean;
+}
+export interface MidsceneYamlFlowItemAIAssert {
+    aiAssert: string;
+    errorMessage?: string;
+}
+export interface MidsceneYamlFlowItemAIQuery extends InsightExtractOption {
+    aiQuery: string;
+    name?: string;
+}
+export interface MidsceneYamlFlowItemAINumber extends InsightExtractOption {
+    aiNumber: string;
+    name?: string;
+}
+export interface MidsceneYamlFlowItemAIString extends InsightExtractOption {
+    aiString: string;
+    name?: string;
+}
+export interface MidsceneYamlFlowItemAIAsk extends InsightExtractOption {
+    aiAsk: string;
+    name?: string;
+}
+export interface MidsceneYamlFlowItemAIBoolean extends InsightExtractOption {
+    aiBoolean: string;
+    name?: string;
+}
+export interface MidsceneYamlFlowItemAILocate extends LocateOption {
+    aiLocate: string;
+    name?: string;
+}
+export interface MidsceneYamlFlowItemAIWaitFor {
+    aiWaitFor: string;
+    timeout?: number;
+}
+export interface MidsceneYamlFlowItemAITap extends LocateOption {
+    aiTap: TUserPrompt;
+}
+export interface MidsceneYamlFlowItemAIRightClick extends LocateOption {
+    aiRightClick: TUserPrompt;
+}
+export interface MidsceneYamlFlowItemAIHover extends LocateOption {
+    aiHover: TUserPrompt;
+}
+export interface MidsceneYamlFlowItemAIInput extends LocateOption {
+    aiInput: string;
+    locate: TUserPrompt;
+}
+export interface MidsceneYamlFlowItemAIKeyboardPress extends LocateOption {
+    aiKeyboardPress: string;
+    locate?: TUserPrompt;
+}
+export interface MidsceneYamlFlowItemAIScroll extends LocateOption, ScrollParam {
+    aiScroll: null;
+    locate?: TUserPrompt;
+}
+export interface MidsceneYamlFlowItemEvaluateJavaScript {
+    javascript: string;
+    name?: string;
+}
+export interface MidsceneYamlFlowItemSleep {
+    sleep: number;
+}
+export interface MidsceneYamlFlowItemLogScreenshot {
+    logScreenshot?: string;
+    content?: string;
+}
+export type MidsceneYamlFlowItem = MidsceneYamlFlowItemAIAction | MidsceneYamlFlowItemAIAssert | MidsceneYamlFlowItemAIQuery | MidsceneYamlFlowItemAIWaitFor | MidsceneYamlFlowItemAITap | MidsceneYamlFlowItemAIRightClick | MidsceneYamlFlowItemAIHover | MidsceneYamlFlowItemAIInput | MidsceneYamlFlowItemAIKeyboardPress | MidsceneYamlFlowItemAIScroll | MidsceneYamlFlowItemSleep | MidsceneYamlFlowItemLogScreenshot;
+export interface FreeFn {
+    name: string;
+    fn: () => void;
+}
+export interface ScriptPlayerTaskStatus extends MidsceneYamlTask {
+    status: ScriptPlayerStatusValue;
+    currentStep?: number;
+    totalSteps: number;
+    error?: Error;
+}
+export type ScriptPlayerStatusValue = 'init' | 'running' | 'done' | 'error';
+export interface MidsceneYamlConfig {
+    concurrent?: number;
+    continueOnError?: boolean;
+    summary?: string;
+    shareBrowserContext?: boolean;
+    web?: MidsceneYamlScriptWebEnv;
+    android?: MidsceneYamlScriptAndroidEnv;
+    files: string[];
+    headed?: boolean;
+    keepWindow?: boolean;
+    dotenvOverride?: boolean;
+    dotenvDebug?: boolean;
+}
+export interface MidsceneYamlConfigOutput {
+    format?: 'json';
+    path?: string;
+}
+export interface MidsceneYamlConfigResult {
+    file: string;
+    success: boolean;
+    executed: boolean;
+    output?: string | null;
+    report?: string | null;
+    error?: string;
+    duration?: number;
+}