@opensteer/engine-abp 0.7.0

package/dist/index.d.cts

@@ -0,0 +1,1143 @@
+declare const brandSymbol: unique symbol;
+type Brand<Value, Name extends string> = Value & {
+    readonly [brandSymbol]: Name;
+};
+
+type SessionRef = Brand<string, "SessionRef">;
+type PageRef = Brand<string, "PageRef">;
+type FrameRef = Brand<string, "FrameRef">;
+type DocumentRef = Brand<string, "DocumentRef">;
+type NodeRef = Brand<string, "NodeRef">;
+type NetworkRequestId = Brand<string, "NetworkRequestId">;
+type DownloadRef = Brand<string, "DownloadRef">;
+type DialogRef = Brand<string, "DialogRef">;
+type ChooserRef = Brand<string, "ChooserRef">;
+type WorkerRef = Brand<string, "WorkerRef">;
+type DocumentEpoch = Brand<number, "DocumentEpoch">;
+interface NodeLocator {
+    readonly documentRef: DocumentRef;
+    readonly documentEpoch: DocumentEpoch;
+    readonly nodeRef: NodeRef;
+}
+
+type PageLifecycleState = "opening" | "open" | "closing" | "closed" | "crashed";
+interface PageInfo {
+    readonly pageRef: PageRef;
+    readonly sessionRef: SessionRef;
+    readonly openerPageRef?: PageRef;
+    readonly url: string;
+    readonly title: string;
+    readonly lifecycleState: PageLifecycleState;
+}
+interface FrameInfo {
+    readonly frameRef: FrameRef;
+    readonly pageRef: PageRef;
+    readonly parentFrameRef?: FrameRef;
+    readonly documentRef: DocumentRef;
+    readonly documentEpoch: DocumentEpoch;
+    readonly url: string;
+    readonly name?: string;
+    readonly isMainFrame: boolean;
+}
+
+interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+interface Size {
+    readonly width: number;
+    readonly height: number;
+}
+interface Rect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+type Quad = readonly [Point, Point, Point, Point];
+interface ScrollOffset {
+    readonly x: number;
+    readonly y: number;
+}
+type CoordinateSpace = "document-css" | "layout-viewport-css" | "visual-viewport-css" | "computer-display-css" | "window" | "screen" | "device-pixel";
+interface LayoutViewport {
+    readonly origin: Point;
+    readonly size: Size;
+}
+interface VisualViewport {
+    readonly origin: Point;
+    readonly offsetWithinLayoutViewport: ScrollOffset;
+    readonly size: Size;
+}
+type DevicePixelRatio = Brand<number, "DevicePixelRatio">;
+type PageScaleFactor = Brand<number, "PageScaleFactor">;
+type PageZoomFactor = Brand<number, "PageZoomFactor">;
+interface ViewportMetrics {
+    readonly layoutViewport: LayoutViewport;
+    readonly visualViewport: VisualViewport;
+    readonly scrollOffset: ScrollOffset;
+    readonly contentSize: Size;
+    readonly devicePixelRatio: DevicePixelRatio;
+    readonly pageScaleFactor: PageScaleFactor;
+    readonly pageZoomFactor: PageZoomFactor;
+}
+
+interface HeaderEntry {
+    readonly name: string;
+    readonly value: string;
+}
+type BodyPayloadEncoding = "identity" | "base64" | "gzip" | "deflate" | "brotli" | "unknown";
+interface BodyPayload {
+    readonly bytes: Uint8Array;
+    readonly encoding: BodyPayloadEncoding;
+    readonly mimeType?: string;
+    readonly charset?: string;
+    readonly truncated: boolean;
+    readonly capturedByteLength: number;
+    readonly originalByteLength?: number;
+}
+type NetworkCaptureState = "pending" | "complete" | "failed" | "skipped";
+type NetworkRecordKind = "http" | "websocket" | "event-stream";
+type NetworkResourceType = "document" | "stylesheet" | "image" | "media" | "font" | "script" | "fetch" | "xhr" | "websocket" | "event-stream" | "manifest" | "texttrack" | "beacon" | "ping" | "preflight" | "other";
+type NetworkInitiatorType = "parser" | "script" | "preload" | "redirect" | "user" | "service-worker" | "other";
+interface NetworkInitiator {
+    readonly type: NetworkInitiatorType;
+    readonly url?: string;
+    readonly lineNumber?: number;
+    readonly columnNumber?: number;
+    readonly requestId?: NetworkRequestId;
+    readonly stackTrace?: readonly string[];
+}
+interface NetworkTiming {
+    readonly requestStartMs?: number;
+    readonly dnsStartMs?: number;
+    readonly dnsEndMs?: number;
+    readonly connectStartMs?: number;
+    readonly connectEndMs?: number;
+    readonly sslStartMs?: number;
+    readonly sslEndMs?: number;
+    readonly requestSentMs?: number;
+    readonly responseStartMs?: number;
+    readonly responseEndMs?: number;
+    readonly workerStartMs?: number;
+    readonly workerReadyMs?: number;
+}
+interface NetworkTransferSizes {
+    readonly requestHeadersBytes?: number;
+    readonly responseHeadersBytes?: number;
+    readonly encodedBodyBytes?: number;
+    readonly decodedBodyBytes?: number;
+    readonly transferSizeBytes?: number;
+}
+interface NetworkSourceMetadata {
+    readonly protocol?: string;
+    readonly remoteAddress?: {
+        readonly ip?: string;
+        readonly port?: number;
+    };
+    readonly fromServiceWorker?: boolean;
+    readonly fromDiskCache?: boolean;
+    readonly fromMemoryCache?: boolean;
+    readonly workerRef?: WorkerRef;
+}
+interface NetworkRecord {
+    readonly kind: NetworkRecordKind;
+    readonly requestId: NetworkRequestId;
+    readonly sessionRef: SessionRef;
+    readonly pageRef?: PageRef;
+    readonly frameRef?: FrameRef;
+    readonly documentRef?: DocumentRef;
+    readonly method: string;
+    readonly url: string;
+    readonly requestHeaders: readonly HeaderEntry[];
+    readonly responseHeaders: readonly HeaderEntry[];
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly resourceType: NetworkResourceType;
+    readonly redirectFromRequestId?: NetworkRequestId;
+    readonly redirectToRequestId?: NetworkRequestId;
+    readonly navigationRequest: boolean;
+    readonly initiator?: NetworkInitiator;
+    readonly timing?: NetworkTiming;
+    readonly transfer?: NetworkTransferSizes;
+    readonly source?: NetworkSourceMetadata;
+    readonly captureState: NetworkCaptureState;
+    readonly requestBodyState: NetworkCaptureState;
+    readonly responseBodyState: NetworkCaptureState;
+    readonly requestBodySkipReason?: string;
+    readonly responseBodySkipReason?: string;
+    readonly requestBodyError?: string;
+    readonly responseBodyError?: string;
+    readonly requestBody?: BodyPayload;
+    readonly responseBody?: BodyPayload;
+}
+interface NetworkRecordFilterInput {
+    readonly url?: string;
+    readonly hostname?: string;
+    readonly path?: string;
+    readonly method?: string;
+    readonly status?: string;
+    readonly resourceType?: NetworkResourceType;
+}
+
+type ScreenshotFormat = "png" | "jpeg" | "webp";
+interface ScreenshotArtifact {
+    readonly pageRef: PageRef;
+    readonly frameRef?: FrameRef;
+    readonly documentRef?: DocumentRef;
+    readonly documentEpoch?: DocumentEpoch;
+    readonly payload: BodyPayload;
+    readonly format: ScreenshotFormat;
+    readonly size: Size;
+    readonly coordinateSpace: CoordinateSpace;
+    readonly clip?: Rect;
+}
+interface HtmlSnapshot {
+    readonly pageRef: PageRef;
+    readonly frameRef: FrameRef;
+    readonly documentRef: DocumentRef;
+    readonly documentEpoch: DocumentEpoch;
+    readonly url: string;
+    readonly capturedAt: number;
+    readonly html: string;
+}
+interface DomSnapshotNode {
+    readonly snapshotNodeId: number;
+    readonly nodeRef?: NodeRef;
+    readonly parentSnapshotNodeId?: number;
+    readonly childSnapshotNodeIds: readonly number[];
+    readonly shadowRootType?: "open" | "closed" | "user-agent";
+    readonly shadowHostNodeRef?: NodeRef;
+    readonly contentDocumentRef?: DocumentRef;
+    readonly nodeType: number;
+    readonly nodeName: string;
+    readonly nodeValue: string;
+    readonly textContent?: string;
+    readonly computedStyle?: {
+        readonly display?: string;
+        readonly visibility?: string;
+        readonly opacity?: string;
+        readonly position?: string;
+        readonly cursor?: string;
+        readonly overflowX?: string;
+        readonly overflowY?: string;
+    };
+    readonly attributes: readonly {
+        readonly name: string;
+        readonly value: string;
+    }[];
+    readonly layout?: {
+        readonly rect?: Rect;
+        readonly quad?: Quad;
+        readonly paintOrder?: number;
+    };
+}
+type ShadowDomSnapshotMode = "flattened" | "preserved" | "unsupported";
+interface DomSnapshot {
+    readonly pageRef: PageRef;
+    readonly frameRef: FrameRef;
+    readonly documentRef: DocumentRef;
+    readonly parentDocumentRef?: DocumentRef;
+    readonly documentEpoch: DocumentEpoch;
+    readonly url: string;
+    readonly capturedAt: number;
+    readonly rootSnapshotNodeId: number;
+    readonly shadowDomMode: ShadowDomSnapshotMode;
+    readonly geometryCoordinateSpace?: CoordinateSpace;
+    readonly nodes: readonly DomSnapshotNode[];
+}
+interface HitTestResult {
+    readonly inputPoint: Point;
+    readonly inputCoordinateSpace: CoordinateSpace;
+    readonly resolvedPoint: Point;
+    readonly resolvedCoordinateSpace: CoordinateSpace;
+    readonly pageRef: PageRef;
+    readonly frameRef: FrameRef;
+    readonly documentRef: DocumentRef;
+    readonly documentEpoch: DocumentEpoch;
+    readonly nodeRef?: NodeRef;
+    readonly targetQuad?: Quad;
+    readonly obscured: boolean;
+    readonly pointerEventsSkipped: boolean;
+}
+type VisualStabilityScope = "main-frame" | "visible-frames";
+
+type CookieSameSite = "strict" | "lax" | "none";
+type CookiePriority = "low" | "medium" | "high";
+interface CookieRecord {
+    readonly sessionRef: SessionRef;
+    readonly name: string;
+    readonly value: string;
+    readonly domain: string;
+    readonly path: string;
+    readonly secure: boolean;
+    readonly httpOnly: boolean;
+    readonly sameSite?: CookieSameSite;
+    readonly priority?: CookiePriority;
+    readonly partitionKey?: string;
+    readonly session: boolean;
+    readonly expiresAt?: number | null;
+}
+interface StorageEntry {
+    readonly key: string;
+    readonly value: string;
+}
+interface IndexedDbRecord {
+    readonly key: unknown;
+    readonly primaryKey?: unknown;
+    readonly value: unknown;
+}
+interface IndexedDbIndexSnapshot {
+    readonly name: string;
+    readonly keyPath?: string | readonly string[];
+    readonly multiEntry: boolean;
+    readonly unique: boolean;
+}
+interface IndexedDbObjectStoreSnapshot {
+    readonly name: string;
+    readonly keyPath?: string | readonly string[];
+    readonly autoIncrement: boolean;
+    readonly indexes: readonly IndexedDbIndexSnapshot[];
+    readonly records: readonly IndexedDbRecord[];
+}
+interface IndexedDbDatabaseSnapshot {
+    readonly name: string;
+    readonly version: number;
+    readonly objectStores: readonly IndexedDbObjectStoreSnapshot[];
+}
+interface StorageOriginSnapshot {
+    readonly origin: string;
+    readonly localStorage: readonly StorageEntry[];
+    readonly indexedDb?: readonly IndexedDbDatabaseSnapshot[];
+}
+interface SessionStorageSnapshot {
+    readonly pageRef: PageRef;
+    readonly frameRef: FrameRef;
+    readonly origin: string;
+    readonly entries: readonly StorageEntry[];
+}
+interface StorageSnapshot {
+    readonly sessionRef: SessionRef;
+    readonly capturedAt: number;
+    readonly origins: readonly StorageOriginSnapshot[];
+    readonly sessionStorage?: readonly SessionStorageSnapshot[];
+}
+
+interface BrowserCapabilities {
+    readonly executor: {
+        readonly sessionLifecycle: boolean;
+        readonly pageLifecycle: boolean;
+        readonly navigation: boolean;
+        readonly pointerInput: boolean;
+        readonly keyboardInput: boolean;
+        readonly touchInput: boolean;
+        readonly screenshots: boolean;
+        readonly executionControl: {
+            readonly pause: boolean;
+            readonly resume: boolean;
+            readonly freeze: boolean;
+        };
+    };
+    readonly inspector: {
+        readonly pageEnumeration: boolean;
+        readonly frameEnumeration: boolean;
+        readonly html: boolean;
+        readonly domSnapshot: boolean;
+        readonly visualStability: boolean;
+        readonly text: boolean;
+        readonly attributes: boolean;
+        readonly hitTest: boolean;
+        readonly viewportMetrics: boolean;
+        readonly network: boolean;
+        readonly networkBodies: boolean;
+        readonly cookies: boolean;
+        readonly localStorage: boolean;
+        readonly sessionStorage: boolean;
+        readonly indexedDb: boolean;
+    };
+    readonly transport: {
+        readonly sessionHttp: boolean;
+    };
+    readonly instrumentation: {
+        readonly initScripts: boolean;
+        readonly routing: boolean;
+    };
+    readonly events: {
+        readonly pageLifecycle: boolean;
+        readonly dialog: boolean;
+        readonly download: boolean;
+        readonly chooser: boolean;
+        readonly worker: boolean;
+        readonly console: boolean;
+        readonly pageError: boolean;
+        readonly websocket: boolean;
+        readonly eventStream: boolean;
+        readonly executionState: boolean;
+    };
+}
+
+type ConsoleLevel = "debug" | "log" | "info" | "warn" | "error" | "trace";
+interface StepEventBase {
+    readonly eventId: string;
+    readonly kind: string;
+    readonly timestamp: number;
+    readonly sessionRef: SessionRef;
+    readonly pageRef?: PageRef;
+    readonly frameRef?: FrameRef;
+    readonly documentRef?: DocumentRef;
+    readonly documentEpoch?: DocumentEpoch;
+}
+interface PageCreatedStepEvent extends StepEventBase {
+    readonly kind: "page-created";
+    readonly pageRef: PageRef;
+}
+interface PopupOpenedStepEvent extends StepEventBase {
+    readonly kind: "popup-opened";
+    readonly pageRef: PageRef;
+    readonly openerPageRef: PageRef;
+}
+interface PageClosedStepEvent extends StepEventBase {
+    readonly kind: "page-closed";
+    readonly pageRef: PageRef;
+}
+interface DialogOpenedStepEvent extends StepEventBase {
+    readonly kind: "dialog-opened";
+    readonly dialogRef: DialogRef;
+    readonly dialogType: "alert" | "beforeunload" | "confirm" | "prompt";
+    readonly message: string;
+    readonly defaultValue?: string;
+}
+interface DownloadStartedStepEvent extends StepEventBase {
+    readonly kind: "download-started";
+    readonly downloadRef: DownloadRef;
+    readonly url: string;
+    readonly suggestedFilename?: string;
+}
+interface DownloadFinishedStepEvent extends StepEventBase {
+    readonly kind: "download-finished";
+    readonly downloadRef: DownloadRef;
+    readonly state: "completed" | "canceled" | "failed";
+    readonly filePath?: string;
+}
+interface ChooserOpenedStepEvent extends StepEventBase {
+    readonly kind: "chooser-opened";
+    readonly chooserRef: ChooserRef;
+    readonly chooserType: "file" | "select";
+    readonly multiple: boolean;
+    readonly options?: readonly {
+        readonly index: number;
+        readonly label: string;
+        readonly value: string;
+        readonly selected: boolean;
+    }[];
+}
+interface WorkerCreatedStepEvent extends StepEventBase {
+    readonly kind: "worker-created";
+    readonly workerRef: WorkerRef;
+    readonly workerType: "dedicated" | "shared" | "service";
+    readonly url: string;
+}
+interface WorkerDestroyedStepEvent extends StepEventBase {
+    readonly kind: "worker-destroyed";
+    readonly workerRef: WorkerRef;
+    readonly workerType: "dedicated" | "shared" | "service";
+    readonly url: string;
+}
+interface ConsoleStepEvent extends StepEventBase {
+    readonly kind: "console";
+    readonly level: ConsoleLevel;
+    readonly text: string;
+    readonly location?: {
+        readonly url?: string;
+        readonly lineNumber?: number;
+        readonly columnNumber?: number;
+    };
+}
+interface PageErrorStepEvent extends StepEventBase {
+    readonly kind: "page-error";
+    readonly message: string;
+    readonly stack?: string;
+}
+interface WebSocketOpenedStepEvent extends StepEventBase {
+    readonly kind: "websocket-opened";
+    readonly socketId: string;
+    readonly url: string;
+}
+interface WebSocketFrameStepEvent extends StepEventBase {
+    readonly kind: "websocket-frame";
+    readonly socketId: string;
+    readonly direction: "sent" | "received";
+    readonly opcode?: number;
+    readonly payloadPreview?: string;
+}
+interface WebSocketClosedStepEvent extends StepEventBase {
+    readonly kind: "websocket-closed";
+    readonly socketId: string;
+    readonly code?: number;
+    readonly reason?: string;
+}
+interface EventStreamMessageStepEvent extends StepEventBase {
+    readonly kind: "event-stream-message";
+    readonly streamId: string;
+    readonly eventName?: string;
+    readonly dataPreview?: string;
+}
+interface PausedStepEvent extends StepEventBase {
+    readonly kind: "paused";
+    readonly reason?: string;
+}
+interface ResumedStepEvent extends StepEventBase {
+    readonly kind: "resumed";
+    readonly reason?: string;
+}
+interface FrozenStepEvent extends StepEventBase {
+    readonly kind: "frozen";
+    readonly reason?: string;
+}
+type StepEvent = PageCreatedStepEvent | PopupOpenedStepEvent | PageClosedStepEvent | DialogOpenedStepEvent | DownloadStartedStepEvent | DownloadFinishedStepEvent | ChooserOpenedStepEvent | WorkerCreatedStepEvent | WorkerDestroyedStepEvent | ConsoleStepEvent | PageErrorStepEvent | WebSocketOpenedStepEvent | WebSocketFrameStepEvent | WebSocketClosedStepEvent | EventStreamMessageStepEvent | PausedStepEvent | ResumedStepEvent | FrozenStepEvent;
+interface StepResult<TData = void> {
+    readonly stepId: string;
+    readonly sessionRef: SessionRef;
+    readonly pageRef?: PageRef;
+    readonly frameRef?: FrameRef;
+    readonly documentRef?: DocumentRef;
+    readonly documentEpoch?: DocumentEpoch;
+    readonly startedAt: number;
+    readonly completedAt: number;
+    readonly durationMs: number;
+    readonly events: readonly StepEvent[];
+    readonly data: TData;
+}
+
+type MouseButton = "left" | "middle" | "right";
+type KeyModifier = "Shift" | "Control" | "Alt" | "Meta";
+interface SessionTransportRequest {
+    readonly method: string;
+    readonly url: string;
+    readonly headers?: readonly HeaderEntry[];
+    readonly body?: BodyPayload;
+    readonly timeoutMs?: number;
+    readonly followRedirects?: boolean;
+}
+interface SessionTransportResponse {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: readonly HeaderEntry[];
+    readonly body?: BodyPayload;
+    readonly redirected: boolean;
+}
+interface BrowserInitScriptInput {
+    readonly sessionRef: SessionRef;
+    readonly pageRef?: PageRef;
+    readonly script: string;
+    readonly args?: readonly unknown[];
+}
+interface BrowserInitScriptRegistration {
+    readonly registrationId: string;
+    readonly sessionRef: SessionRef;
+    readonly pageRef?: PageRef;
+}
+interface BrowserRouteRequest {
+    readonly url: string;
+    readonly method: string;
+    readonly headers: readonly HeaderEntry[];
+    readonly resourceType: NetworkRecord["resourceType"];
+    readonly pageRef?: PageRef;
+    readonly postData?: BodyPayload;
+}
+interface BrowserRouteFetchResult extends SessionTransportResponse {
+}
+type BrowserRouteHandlerResult = {
+    readonly kind: "continue";
+} | {
+    readonly kind: "fulfill";
+    readonly status?: number;
+    readonly headers?: readonly HeaderEntry[];
+    readonly body?: BodyPayload;
+    readonly contentType?: string;
+} | {
+    readonly kind: "abort";
+    readonly errorCode?: string;
+};
+interface BrowserRouteRegistrationInput {
+    readonly sessionRef: SessionRef;
+    readonly pageRef?: PageRef;
+    readonly urlPattern: string;
+    readonly resourceTypes?: readonly NetworkRecord["resourceType"][];
+    readonly times?: number;
+    readonly handler: (input: {
+        readonly request: BrowserRouteRequest;
+        fetchOriginal(): Promise<BrowserRouteFetchResult>;
+    }) => Promise<BrowserRouteHandlerResult> | BrowserRouteHandlerResult;
+}
+interface BrowserRouteRegistration {
+    readonly routeId: string;
+    readonly sessionRef: SessionRef;
+    readonly pageRef?: PageRef;
+    readonly urlPattern: string;
+}
+interface GetNetworkRecordsInput extends NetworkRecordFilterInput {
+    readonly sessionRef: SessionRef;
+    readonly pageRef?: PageRef;
+    readonly requestIds?: readonly string[];
+    readonly includeBodies?: boolean;
+    readonly signal?: AbortSignal;
+}
+interface BrowserExecutor {
+    readonly capabilities: Readonly<BrowserCapabilities>;
+    createSession(): Promise<SessionRef>;
+    closeSession(input: {
+        readonly sessionRef: SessionRef;
+    }): Promise<void>;
+    createPage(input: {
+        readonly sessionRef: SessionRef;
+        readonly openerPageRef?: PageRef;
+        readonly url?: string;
+    }): Promise<StepResult<PageInfo>>;
+    closePage(input: {
+        readonly pageRef: PageRef;
+    }): Promise<StepResult<void>>;
+    activatePage(input: {
+        readonly pageRef: PageRef;
+    }): Promise<StepResult<PageInfo>>;
+    navigate(input: {
+        readonly pageRef: PageRef;
+        readonly url: string;
+        readonly referrer?: string;
+        readonly timeoutMs?: number;
+    }): Promise<StepResult<{
+        readonly pageInfo: PageInfo;
+        readonly mainFrame: FrameInfo;
+    }>>;
+    reload(input: {
+        readonly pageRef: PageRef;
+        readonly timeoutMs?: number;
+    }): Promise<StepResult<{
+        readonly pageInfo: PageInfo;
+        readonly mainFrame: FrameInfo;
+    }>>;
+    goBack(input: {
+        readonly pageRef: PageRef;
+    }): Promise<StepResult<boolean>>;
+    goForward(input: {
+        readonly pageRef: PageRef;
+    }): Promise<StepResult<boolean>>;
+    stopLoading(input: {
+        readonly pageRef: PageRef;
+    }): Promise<StepResult<void>>;
+    mouseMove(input: {
+        readonly pageRef: PageRef;
+        readonly point: Point;
+        readonly coordinateSpace: CoordinateSpace;
+    }): Promise<StepResult<void>>;
+    mouseClick(input: {
+        readonly pageRef: PageRef;
+        readonly point: Point;
+        readonly coordinateSpace: CoordinateSpace;
+        readonly button?: MouseButton;
+        readonly clickCount?: number;
+        readonly modifiers?: readonly KeyModifier[];
+    }): Promise<StepResult<HitTestResult | undefined>>;
+    mouseScroll(input: {
+        readonly pageRef: PageRef;
+        readonly point: Point;
+        readonly coordinateSpace: CoordinateSpace;
+        readonly delta: Point;
+    }): Promise<StepResult<void>>;
+    keyPress(input: {
+        readonly pageRef: PageRef;
+        readonly key: string;
+        readonly modifiers?: readonly KeyModifier[];
+    }): Promise<StepResult<void>>;
+    textInput(input: {
+        readonly pageRef: PageRef;
+        readonly text: string;
+    }): Promise<StepResult<void>>;
+    captureScreenshot(input: {
+        readonly pageRef: PageRef;
+        readonly format?: ScreenshotFormat;
+        readonly clip?: Rect;
+        readonly clipSpace?: CoordinateSpace;
+        readonly fullPage?: boolean;
+        readonly includeCursor?: boolean;
+    }): Promise<StepResult<ScreenshotArtifact>>;
+    setExecutionState(input: {
+        readonly pageRef: PageRef;
+        readonly paused?: boolean;
+        readonly frozen?: boolean;
+    }): Promise<StepResult<{
+        readonly paused: boolean;
+        readonly frozen: boolean;
+    }>>;
+}
+interface BrowserInspector {
+    readonly capabilities: Readonly<BrowserCapabilities>;
+    listPages(input: {
+        readonly sessionRef: SessionRef;
+    }): Promise<readonly PageInfo[]>;
+    listFrames(input: {
+        readonly pageRef: PageRef;
+    }): Promise<readonly FrameInfo[]>;
+    getPageInfo(input: {
+        readonly pageRef: PageRef;
+    }): Promise<PageInfo>;
+    getFrameInfo(input: {
+        readonly frameRef: FrameRef;
+    }): Promise<FrameInfo>;
+    getHtmlSnapshot(input: {
+        readonly frameRef?: FrameRef;
+        readonly documentRef?: DocumentRef;
+    }): Promise<HtmlSnapshot>;
+    getDomSnapshot(input: {
+        readonly frameRef?: FrameRef;
+        readonly documentRef?: DocumentRef;
+    }): Promise<DomSnapshot>;
+    waitForVisualStability(input: {
+        readonly pageRef: PageRef;
+        readonly timeoutMs?: number;
+        readonly settleMs?: number;
+        readonly scope?: VisualStabilityScope;
+    }): Promise<void>;
+    readText(input: NodeLocator): Promise<string | null>;
+    readAttributes(input: NodeLocator): Promise<readonly {
+        readonly name: string;
+        readonly value: string;
+    }[]>;
+    hitTest(input: {
+        readonly pageRef: PageRef;
+        readonly point: Point;
+        readonly coordinateSpace: CoordinateSpace;
+        readonly ignorePointerEventsNone?: boolean;
+        readonly includeUserAgentShadowDom?: boolean;
+    }): Promise<HitTestResult>;
+    getViewportMetrics(input: {
+        readonly pageRef: PageRef;
+    }): Promise<ViewportMetrics>;
+    getNetworkRecords(input: GetNetworkRecordsInput): Promise<readonly NetworkRecord[]>;
+    getCookies(input: {
+        readonly sessionRef: SessionRef;
+        readonly urls?: readonly string[];
+    }): Promise<readonly CookieRecord[]>;
+    setCookies(input: {
+        readonly sessionRef: SessionRef;
+        readonly cookies: readonly CookieRecord[];
+    }): Promise<void>;
+    getStorageSnapshot(input: {
+        readonly sessionRef: SessionRef;
+        readonly includeSessionStorage?: boolean;
+        readonly includeIndexedDb?: boolean;
+    }): Promise<StorageSnapshot>;
+    evaluatePage(input: {
+        readonly pageRef: PageRef;
+        readonly script: string;
+        readonly args?: readonly unknown[];
+        readonly timeoutMs?: number;
+    }): Promise<StepResult<unknown>>;
+}
+interface SessionTransportExecutor {
+    readonly capabilities: Readonly<BrowserCapabilities>;
+    executeRequest(input: {
+        readonly sessionRef: SessionRef;
+        readonly request: SessionTransportRequest;
+        readonly signal?: AbortSignal;
+    }): Promise<StepResult<SessionTransportResponse>>;
+}
+interface BrowserInstrumentation {
+    readonly capabilities: Readonly<BrowserCapabilities>;
+    addInitScript(input: BrowserInitScriptInput): Promise<BrowserInitScriptRegistration>;
+    registerRoute(input: BrowserRouteRegistrationInput): Promise<BrowserRouteRegistration>;
+}
+interface BrowserCoreEngine extends BrowserExecutor, BrowserInspector, SessionTransportExecutor, BrowserInstrumentation {
+}
+
+declare const opensteerComputerAnnotationNames: readonly ["clickable", "typeable", "scrollable", "grid", "selected"];
+type OpensteerComputerAnnotation = (typeof opensteerComputerAnnotationNames)[number];
+type OpensteerComputerMouseButton = "left" | "middle" | "right";
+type OpensteerComputerKeyModifier = "Shift" | "Control" | "Alt" | "Meta";
+interface OpensteerComputerClickAction {
+    readonly type: "click";
+    readonly x: number;
+    readonly y: number;
+    readonly button?: OpensteerComputerMouseButton;
+    readonly clickCount?: number;
+    readonly modifiers?: readonly OpensteerComputerKeyModifier[];
+}
+interface OpensteerComputerMoveAction {
+    readonly type: "move";
+    readonly x: number;
+    readonly y: number;
+}
+interface OpensteerComputerScrollAction {
+    readonly type: "scroll";
+    readonly x: number;
+    readonly y: number;
+    readonly deltaX: number;
+    readonly deltaY: number;
+}
+interface OpensteerComputerTypeAction {
+    readonly type: "type";
+    readonly text: string;
+}
+interface OpensteerComputerKeyAction {
+    readonly type: "key";
+    readonly key: string;
+    readonly modifiers?: readonly OpensteerComputerKeyModifier[];
+}
+interface OpensteerComputerDragAction {
+    readonly type: "drag";
+    readonly start: Point;
+    readonly end: Point;
+    readonly steps?: number;
+}
+interface OpensteerComputerScreenshotAction {
+    readonly type: "screenshot";
+}
+interface OpensteerComputerWaitAction {
+    readonly type: "wait";
+    readonly durationMs: number;
+}
+type OpensteerComputerAction = OpensteerComputerClickAction | OpensteerComputerMoveAction | OpensteerComputerScrollAction | OpensteerComputerTypeAction | OpensteerComputerKeyAction | OpensteerComputerDragAction | OpensteerComputerScreenshotAction | OpensteerComputerWaitAction;
+interface OpensteerComputerExecuteTiming {
+    readonly actionMs: number;
+    readonly waitMs: number;
+    readonly totalMs: number;
+}
+
+declare const OPENSTEER_COMPUTER_USE_BRIDGE_SYMBOL: unique symbol;
+interface NormalizedComputerScreenshotOptions {
+    readonly format: ScreenshotFormat;
+    readonly includeCursor: boolean;
+    readonly annotations: readonly OpensteerComputerAnnotation[];
+}
+interface ComputerUseBridgeInput {
+    readonly pageRef: PageRef;
+    readonly action: OpensteerComputerAction;
+    readonly screenshot: NormalizedComputerScreenshotOptions;
+    readonly signal: AbortSignal;
+    remainingMs(): number | undefined;
+    policySettle(pageRef: PageRef): Promise<void>;
+}
+interface ComputerUseBridgeOutput {
+    readonly pageRef: PageRef;
+    readonly screenshot: ScreenshotArtifact;
+    readonly viewport: ViewportMetrics;
+    readonly events: readonly StepEvent[];
+    readonly timing: OpensteerComputerExecuteTiming;
+}
+interface ComputerUseBridge {
+    execute(input: ComputerUseBridgeInput): Promise<ComputerUseBridgeOutput>;
+}
+
+declare const OPENSTEER_DOM_ACTION_BRIDGE_SYMBOL: unique symbol;
+type DomActionScrollAlignment = "start" | "center" | "end" | "nearest";
+interface DomActionTargetInspection {
+    readonly connected: boolean;
+    readonly visible: boolean;
+    readonly enabled: boolean;
+    readonly editable: boolean;
+    readonly pointerEvents: string;
+    readonly bounds?: Rect;
+    readonly contentQuads: readonly Quad[];
+}
+interface DomActionScrollOptions {
+    readonly block?: DomActionScrollAlignment;
+    readonly inline?: DomActionScrollAlignment;
+}
+interface DomActionKeyPressInput {
+    readonly key: string;
+    readonly modifiers?: readonly KeyModifier[];
+}
+interface DomActionSettleOptions {
+    readonly operation: "dom.click" | "dom.hover" | "dom.input" | "dom.scroll";
+    readonly signal: AbortSignal;
+    remainingMs(): number | undefined;
+    policySettle(pageRef: PageRef): Promise<void>;
+}
+type DomPointerHitRelation = "self" | "descendant" | "ancestor" | "same-owner" | "outside" | "unknown";
+interface DomPointerHitAssessment {
+    readonly relation: DomPointerHitRelation;
+    readonly blocking: boolean;
+    readonly ambiguous?: boolean;
+    readonly canonicalTarget?: NodeLocator;
+    readonly hitOwner?: NodeLocator;
+}
+interface DomActionBridge {
+    inspectActionTarget(locator: NodeLocator): Promise<DomActionTargetInspection>;
+    canonicalizePointerTarget(locator: NodeLocator): Promise<NodeLocator>;
+    classifyPointerHit(input: {
+        readonly target: NodeLocator;
+        readonly hit: NodeLocator;
+        readonly point: Point;
+    }): Promise<DomPointerHitAssessment>;
+    scrollNodeIntoView(locator: NodeLocator, options?: DomActionScrollOptions): Promise<void>;
+    focusNode(locator: NodeLocator): Promise<void>;
+    pressKey(locator: NodeLocator, input: DomActionKeyPressInput): Promise<void>;
+    finalizeDomAction(pageRef: PageRef, options: DomActionSettleOptions): Promise<void>;
+}
+
+interface AbpLaunchOptions {
+    readonly abpExecutablePath?: string;
+    readonly browserExecutablePath?: string;
+    readonly headless?: boolean;
+    readonly userDataDir?: string;
+    readonly sessionDir?: string;
+    readonly args?: readonly string[];
+    readonly verbose?: boolean;
+}
+interface AdoptedAbpBrowser {
+    readonly baseUrl: string;
+    readonly remoteDebuggingUrl: string;
+}
+interface AbpBrowserCoreEngineOptions {
+    readonly launch?: AbpLaunchOptions;
+    readonly browser?: AdoptedAbpBrowser;
+    readonly extraHTTPHeaders?: readonly HeaderEntry[];
+}
+
+declare class AbpBrowserCoreEngine implements BrowserCoreEngine {
+    readonly capabilities: BrowserCapabilities;
+    private readonly launchOptions;
+    private readonly adoptedBrowser;
+    private readonly extraHTTPHeaders;
+    private readonly sessions;
+    private readonly pages;
+    private readonly frames;
+    private readonly documents;
+    private readonly retiredDocuments;
+    private readonly downloadRefsByAbpId;
+    private readonly actionSettler;
+    private pageCounter;
+    private frameCounter;
+    private documentCounter;
+    private nodeCounter;
+    private requestCounter;
+    private sessionCounter;
+    private computerUseBridge;
+    private domActionBridge;
+    private eventCounter;
+    private stepCounter;
+    private dialogCounter;
+    private chooserCounter;
+    private downloadCounter;
+    private disposed;
+    private constructor();
+    static create(options?: AbpBrowserCoreEngineOptions): Promise<AbpBrowserCoreEngine>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    [OPENSTEER_COMPUTER_USE_BRIDGE_SYMBOL](): ComputerUseBridge;
+    [OPENSTEER_DOM_ACTION_BRIDGE_SYMBOL](): DomActionBridge;
+    createSession(): Promise<SessionRef>;
+    closeSession(input: {
+        readonly sessionRef: SessionRef;
+    }): Promise<void>;
+    createPage(input: {
+        readonly sessionRef: SessionRef;
+        readonly openerPageRef?: PageRef;
+        readonly url?: string;
+    }): Promise<StepResult<PageInfo>>;
+    closePage(input: {
+        readonly pageRef: PageRef;
+    }): Promise<StepResult<void>>;
+    activatePage(input: {
+        readonly pageRef: PageRef;
+    }): Promise<StepResult<PageInfo>>;
+    navigate(input: {
+        readonly pageRef: PageRef;
+        readonly url: string;
+        readonly referrer?: string;
+        readonly timeoutMs?: number;
+    }): Promise<StepResult<{
+        readonly pageInfo: PageInfo;
+        readonly mainFrame: FrameInfo;
+    }>>;
+    reload(input: {
+        readonly pageRef: PageRef;
+        readonly timeoutMs?: number;
+    }): Promise<StepResult<{
+        readonly pageInfo: PageInfo;
+        readonly mainFrame: FrameInfo;
+    }>>;
+    goBack(input: {
+        readonly pageRef: PageRef;
+    }): Promise<StepResult<boolean>>;
+    goForward(input: {
+        readonly pageRef: PageRef;
+    }): Promise<StepResult<boolean>>;
+    stopLoading(input: {
+        readonly pageRef: PageRef;
+    }): Promise<StepResult<void>>;
+    mouseMove(input: {
+        readonly pageRef: PageRef;
+        readonly point: Point;
+        readonly coordinateSpace: CoordinateSpace;
+    }): Promise<StepResult<void>>;
+    mouseClick(input: {
+        readonly pageRef: PageRef;
+        readonly point: Point;
+        readonly coordinateSpace: CoordinateSpace;
+        readonly button?: MouseButton;
+        readonly clickCount?: number;
+        readonly modifiers?: readonly KeyModifier[];
+    }): Promise<StepResult<HitTestResult | undefined>>;
+    mouseScroll(input: {
+        readonly pageRef: PageRef;
+        readonly point: Point;
+        readonly coordinateSpace: CoordinateSpace;
+        readonly delta: Point;
+    }): Promise<StepResult<void>>;
+    keyPress(input: {
+        readonly pageRef: PageRef;
+        readonly key: string;
+        readonly modifiers?: readonly KeyModifier[];
+    }): Promise<StepResult<void>>;
+    textInput(input: {
+        readonly pageRef: PageRef;
+        readonly text: string;
+    }): Promise<StepResult<void>>;
+    captureScreenshot(input: {
+        readonly pageRef: PageRef;
+        readonly format?: ScreenshotFormat;
+        readonly clip?: Rect;
+        readonly clipSpace?: CoordinateSpace;
+        readonly fullPage?: boolean;
+        readonly includeCursor?: boolean;
+    }): Promise<StepResult<ScreenshotArtifact>>;
+    setExecutionState(input: {
+        readonly pageRef: PageRef;
+        readonly paused?: boolean;
+        readonly frozen?: boolean;
+    }): Promise<StepResult<{
+        readonly paused: boolean;
+        readonly frozen: boolean;
+    }>>;
+    listPages(input: {
+        readonly sessionRef: SessionRef;
+    }): Promise<readonly PageInfo[]>;
+    listFrames(input: {
+        readonly pageRef: PageRef;
+    }): Promise<readonly FrameInfo[]>;
+    getPageInfo(input: {
+        readonly pageRef: PageRef;
+    }): Promise<PageInfo>;
+    getFrameInfo(input: {
+        readonly frameRef: FrameRef;
+    }): Promise<FrameInfo>;
+    getHtmlSnapshot(input: {
+        readonly frameRef?: FrameRef;
+        readonly documentRef?: DocumentRef;
+    }): Promise<HtmlSnapshot>;
+    getDomSnapshot(input: {
+        readonly frameRef?: FrameRef;
+        readonly documentRef?: DocumentRef;
+    }): Promise<DomSnapshot>;
+    waitForVisualStability(input: {
+        readonly pageRef: PageRef;
+        readonly timeoutMs?: number;
+        readonly settleMs?: number;
+        readonly scope?: "main-frame" | "visible-frames";
+    }): Promise<void>;
+    readText(input: NodeLocator): Promise<string | null>;
+    readAttributes(input: NodeLocator): Promise<readonly {
+        readonly name: string;
+        readonly value: string;
+    }[]>;
+    hitTest(input: {
+        readonly pageRef: PageRef;
+        readonly point: Point;
+        readonly coordinateSpace: CoordinateSpace;
+        readonly ignorePointerEventsNone?: boolean;
+        readonly includeUserAgentShadowDom?: boolean;
+    }): Promise<HitTestResult>;
+    getViewportMetrics(input: {
+        readonly pageRef: PageRef;
+    }): Promise<ViewportMetrics>;
+    getNetworkRecords(input: GetNetworkRecordsInput): Promise<readonly NetworkRecord[]>;
+    private readNetworkRecordsForPage;
+    getCookies(input: {
+        readonly sessionRef: SessionRef;
+        readonly urls?: readonly string[];
+    }): Promise<readonly CookieRecord[]>;
+    setCookies(input: {
+        readonly sessionRef: SessionRef;
+        readonly cookies: readonly CookieRecord[];
+    }): Promise<void>;
+    getStorageSnapshot(input: {
+        readonly sessionRef: SessionRef;
+        readonly includeSessionStorage?: boolean;
+        readonly includeIndexedDb?: boolean;
+    }): Promise<StorageSnapshot>;
+    evaluatePage(input: {
+        readonly pageRef: PageRef;
+        readonly script: string;
+        readonly args?: readonly unknown[];
+        readonly timeoutMs?: number;
+    }): Promise<StepResult<unknown>>;
+    addInitScript(_input: BrowserInitScriptInput): Promise<BrowserInitScriptRegistration>;
+    registerRoute(_input: BrowserRouteRegistrationInput): Promise<BrowserRouteRegistration>;
+    executeRequest(input: {
+        readonly sessionRef: SessionRef;
+        readonly request: SessionTransportRequest;
+        readonly signal?: AbortSignal;
+    }): Promise<StepResult<SessionTransportResponse>>;
+    private awaitSessionHttpResponse;
+    private createLaunchSession;
+    private createAdoptedSession;
+    private initializePageController;
+    private handleFrameAttached;
+    private handleFrameDetached;
+    private handleFrameNavigated;
+    private handleNavigatedWithinDocument;
+    private handleDocumentUpdated;
+    private syncFrameTree;
+    private waitForPageTargetInfo;
+    private waitForMainFrame;
+    private waitForNavigationObservation;
+    private captureMainFrameSnapshot;
+    private setControllerExecutionPaused;
+    private syncControllerExecutionPaused;
+    private normalizeActionEvents;
+    private executeInputAction;
+    private detectNewTabs;
+    private applyActionTabChange;
+    private normalizeNetworkRecord;
+    private createSessionHttpNetworkRecord;
+    private storeDocumentNavigationRecord;
+    private markNetworkRecordBodyFailure;
+    private readLocalNetworkRecords;
+    private projectNetworkRecordBodies;
+    private storeNetworkRecords;
+    private readStorageEntriesForOrigin;
+    private readIndexedDbSnapshotForOrigin;
+    private collectSessionStorageSnapshots;
+    private buildPageInfo;
+    private buildFrameInfo;
+    private refreshTabTitle;
+    private reconcileDocumentEpochs;
+    private queueDocumentReconciliation;
+    private flushDomUpdateTask;
+    private captureDomSnapshot;
+    private nodeRefForBackendNode;
+    private resolveDocumentTarget;
+    private requireLiveNode;
+    private requireMainFrame;
+    private requireSession;
+    private requirePage;
+    private requireFrame;
+    private requireDocument;
+    private cleanupPageController;
+    private throwBackgroundError;
+    private createEvent;
+    private queueEvent;
+    private drainQueuedEvents;
+    private createStepResult;
+    private retireDocument;
+    private isDescendantFrame;
+    private isHistoryBoundaryError;
+    private readString;
+    private readBoolean;
+    private assertNotDisposed;
+}
+declare function createAbpBrowserCoreEngine(options?: AbpBrowserCoreEngineOptions): Promise<AbpBrowserCoreEngine>;
+
+export { AbpBrowserCoreEngine, type AbpBrowserCoreEngineOptions, type AbpLaunchOptions, type AdoptedAbpBrowser, createAbpBrowserCoreEngine };