Mac apps API

agent.computer operates Mac apps through Accessibility, with windows and locators shaped like the browser API. The guide agents read is on Mac apps.

Types#

As declared in the repl.d.ts the skills ship. Constructors are left out: code in a cell is handed these objects and doesn’t build them.

`Computer`#

class Computer {
	readonly errors: Readonly<{
		TimeoutError: typeof TimeoutError;
		StrictModeError: typeof StrictModeError;
		TargetClosedError: typeof TargetClosedError;
		AppNotFoundError: typeof AppNotFoundError;
		PermissionDeniedError: typeof PermissionDeniedError;
		ActionNotSupportedError: typeof ActionNotSupportedError;
		ModalOpenError: typeof ModalOpenError;
		CancelledError: typeof CancelledError;
		SessionLockedError: typeof SessionLockedError;
	}>;
	readonly shell: Shell;
	readonly keyboard: Keyboard;
	readonly mouse: Mouse;
	readonly clipboard: Clipboard;
	apps(): Promise<App[]>;
	app(name: string, options?: SignalTimeoutOptions): Promise<App>;
	open(name: string, options?: SignalTimeoutOptions): Promise<App>;
	foregroundForUser(options?: SignalTimeoutOptions): Promise<App>;
	displays(): Promise<Display[]>;
	session(): Promise<Session>;
	permissions(): Promise<Permissions>;
	setDefaultTimeout(timeout: number): void;
	release(): Promise<void>;
}

`TimeoutError`#

class TimeoutError extends Error {
	readonly selector: string;
	readonly condition: string;
	readonly lastObserved: string;
	readonly candidates: string[];
	readonly scope: string;
	readonly elapsedMs: number;
}

`StrictModeError`#

class StrictModeError extends Error {
	readonly selector: string;
	readonly matches: string[];
}

`TargetClosedError`#

class TargetClosedError extends Error {
}

`AppNotFoundError`#

class AppNotFoundError extends Error {
	readonly app: string;
}

`PermissionDeniedError`#

class PermissionDeniedError extends Error {
	readonly pane: string;
	readonly process: string;
}

`ActionNotSupportedError`#

class ActionNotSupportedError extends Error {
	readonly action: string;
	readonly element: string;
	readonly reason: string;
}

`ModalOpenError`#

class ModalOpenError extends Error {
	readonly window: string;
	readonly kind: string;
	readonly title: string;
	readonly buttons: string[];
}

`CancelledError`#

class CancelledError extends Error {
}

`SessionLockedError`#

class SessionLockedError extends Error {
}

`Shell`#

class Shell {
	menuBar(): ComputerLocator;
	statusItems(): ComputerLocator;
	dock(): ComputerLocator;
	notifications(): ComputerLocator;
	desktop(): ComputerLocator;
	on(event: "notification", listener: (banner: ComputerLocator) => unknown): this;
	once(event: "notification", listener: (banner: ComputerLocator) => unknown): this;
	off(event: "notification", listener: (banner: ComputerLocator) => unknown): this;
	addListener(event: "notification", listener: (banner: ComputerLocator) => unknown): this;
	removeListener(event: "notification", listener: (banner: ComputerLocator) => unknown): this;
	waitForEvent(event: "notification", optionsOrPredicate?: {
		predicate?: (banner: ComputerLocator) => boolean | Promise<boolean>;
		timeout?: number;
		signal?: AbortSignal;
	} | ((banner: ComputerLocator) => boolean | Promise<boolean>)): Promise<ComputerLocator>;
}

`Keyboard`#

class Keyboard {
	press(key: string, options?: {
		delay?: number;
	}): Promise<void>;
	type(text: string, options?: {
		delay?: number;
	}): Promise<void>;
	insertText(text: string): Promise<void>;
	down(key: string): Promise<void>;
	up(key: string): Promise<void>;
}

`Mouse`#

class Mouse {
	click(x: number, y: number, options?: {
		button?: "left" | "right" | "middle";
		clickCount?: number;
		delay?: number;
	}): Promise<void>;
	dblclick(x: number, y: number, options?: {
		button?: "left" | "right" | "middle";
		delay?: number;
	}): Promise<void>;
	move(x: number, y: number, options?: {
		steps?: number;
	}): Promise<void>;
	down(options?: {
		button?: "left" | "right" | "middle";
		clickCount?: number;
	}): Promise<void>;
	up(options?: {
		button?: "left" | "right" | "middle";
		clickCount?: number;
	}): Promise<void>;
	wheel(deltaX: number, deltaY: number): Promise<void>;
}

`Clipboard`#

class Clipboard {
	read(): Promise<ClipboardContent>;
	write(content: {
		text: string;
	} | {
		files: string[];
	} | {
		image: Buffer;
	}): Promise<void>;
}

`App`#

class App {
	readonly name: string;
	readonly pid: number;
	readonly bundleIdentifier: string;
	readonly path: string;
	readonly keyboard: Keyboard;
	readonly screencast: Screencast;
	readonly accessibility: AccessibilityEvents;
	isRunning(): boolean;
	isForeground(): Promise<boolean>;
	isForegroundForUser(): Promise<boolean>;
	windows(): ComputerWindow[];
	firstWindow(options?: {
		timeout?: number;
		title?: TextMatcher;
		kind?: WindowKind;
		signal?: AbortSignal;
	}): Promise<ComputerWindow>;
	menuBar(): ComputerLocator;
	setDefaultTimeout(timeout: number): void;
	locator(selector: string, options?: LocatorOptions): ComputerLocator;
	getByRole(role: AriaRole, options?: ByRoleOptions): ComputerLocator;
	getByAltText(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByText(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByLabel(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByPlaceholder(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByTitle(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByTestId(testId: TextMatcher): ComputerLocator;
	ariaSnapshot(options?: SnapshotOptions): Promise<string>;
	ariaSnapshotJSON(options?: SnapshotOptions): Promise<Serializable>;
	screenshot(options?: Omit<ScreenshotOptions, "clip">): Promise<Buffer>;
	bringToFront(): Promise<void>;
	release(): Promise<void>;
	bringToFrontForUser(): Promise<void>;
	close(): Promise<void>;
	on<Event extends keyof AppEventMap>(event: Event, listener: (...args: AppEventMap[Event]) => unknown): this;
	once<Event extends keyof AppEventMap>(event: Event, listener: (...args: AppEventMap[Event]) => unknown): this;
	off<Event extends keyof AppEventMap>(event: Event, listener: (...args: AppEventMap[Event]) => unknown): this;
	addListener<Event extends keyof AppEventMap>(event: Event, listener: (...args: AppEventMap[Event]) => unknown): this;
	removeListener<Event extends keyof AppEventMap>(event: Event, listener: (...args: AppEventMap[Event]) => unknown): this;
	waitForEvent<Event extends keyof AppEventMap>(event: Event, optionsOrPredicate?: {
		predicate?: (...args: AppEventMap[Event]) => boolean | Promise<boolean>;
		timeout?: number;
		signal?: AbortSignal;
	} | ((...args: AppEventMap[Event]) => boolean | Promise<boolean>)): Promise<EventResult<AppEventMap[Event]>>;
}

`SignalTimeoutOptions`#

type SignalTimeoutOptions = {
	signal?: AbortSignal;
	timeout?: number;
};

`Display`#

class Display {
	readonly id: string;
	readonly screencast: Screencast;
	isMain(): Promise<boolean>;
	scale(): Promise<number>;
	bounds(): Promise<ComputerRect>;
	workArea(): Promise<ComputerRect>;
	screenshot(options?: ScreenshotOptions): Promise<Buffer>;
}

`Session`#

type Session = {
	state: "active" | "idle" | "screensaver" | "locked";
	idleSeconds: number;
};

`Permissions`#

type Permissions = {
	accessibility: PermissionState;
	screenRecording: PermissionState;
	inputMonitoring: PermissionState;
};

`ComputerLocator`#

class ComputerLocator {
	locator(selectorOrLocator: string | ComputerLocator, options?: LocatorOptions): ComputerLocator;
	getByRole(role: AriaRole, options?: ByRoleOptions): ComputerLocator;
	getByAltText(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByText(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByLabel(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByPlaceholder(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByTitle(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByTestId(testId: TextMatcher): ComputerLocator;
	filter(options?: LocatorFilterOptions): ComputerLocator;
	and(locator: ComputerLocator): ComputerLocator;
	or(locator: ComputerLocator): ComputerLocator;
	first(): ComputerLocator;
	last(): ComputerLocator;
	nth(index: number): ComputerLocator;
	all(): Promise<ComputerLocator[]>;
	count(): Promise<number>;
	visible(): ComputerLocator;
	describe(description: string): ComputerLocator;
	description(): string | null;
	window(): ComputerWindow | null;
	ariaSnapshot(options?: SnapshotOptions): Promise<string>;
	ariaSnapshotJSON(options?: SnapshotOptions): Promise<Serializable>;
	boundingBox(options?: SignalTimeoutOptions): Promise<ComputerRect | null>;
	getAttribute(name: string, options?: SignalTimeoutOptions): Promise<string | null>;
	innerText(options?: SignalTimeoutOptions): Promise<string>;
	textContent(options?: SignalTimeoutOptions): Promise<string | null>;
	inputValue(options?: SignalTimeoutOptions): Promise<string>;
	allInnerTexts(): Promise<string[]>;
	allTextContents(): Promise<string[]>;
	isVisible(options?: {
		timeout?: number;
	}): Promise<boolean>;
	isHidden(options?: {
		timeout?: number;
	}): Promise<boolean>;
	isEnabled(options?: SignalTimeoutOptions): Promise<boolean>;
	isDisabled(options?: SignalTimeoutOptions): Promise<boolean>;
	isEditable(options?: SignalTimeoutOptions): Promise<boolean>;
	isChecked(options?: SignalTimeoutOptions): Promise<boolean>;
	click(options?: PointerActionOptions): Promise<void>;
	dblclick(options?: PointerActionOptions): Promise<void>;
	hover(options?: PointerActionOptions): Promise<void>;
	dragTo(target: ComputerLocator, options?: DragOptions): Promise<void>;
	fill(value: string, options?: ForceOptions): Promise<void>;
	pressSequentially(text: string, options?: KeyOptions): Promise<void>;
	press(key: string, options?: KeyOptions): Promise<void>;
	check(options?: CheckOptions): Promise<void>;
	uncheck(options?: CheckOptions): Promise<void>;
	setChecked(checked: boolean, options?: CheckOptions): Promise<void>;
	selectOption(values: SelectOptionValue, options?: ForceOptions): Promise<string[]>;
	focus(options?: SignalTimeoutOptions): Promise<void>;
	blur(options?: SignalTimeoutOptions): Promise<void>;
	clear(options?: ForceOptions): Promise<void>;
	selectText(options?: ForceOptions): Promise<void>;
	scrollIntoViewIfNeeded(options?: SignalTimeoutOptions): Promise<void>;
	setInputFiles(files: string | ReadonlyArray<string>, options?: SignalTimeoutOptions): Promise<void>;
	performAction(action: string, options?: SignalTimeoutOptions): Promise<void>;
	screenshot(options?: Omit<ScreenshotOptions, "clip">): Promise<Buffer>;
	waitFor(options?: WaitForOptions): Promise<void>;
	toString(): string;
}

`ClipboardContent`#

type ClipboardContent = {
	text?: string;
	files?: string[];
	image?: Buffer;
};

`Screencast`#

class Screencast {
	start(options?: {
		codec?: "h264" | "hevc";
		onFrame?: (frame: ScreencastFrame) => unknown;
		path?: string;
		quality?: number;
		size?: {
			width: number;
			height: number;
		};
	}): Promise<Disposable>;
	stop(): Promise<void>;
	showChapter(title: string, options?: {
		description?: string;
		duration?: number;
	}): Promise<void>;
	showActions(options?: {
		cursor?: "none" | "pointer";
		duration?: number;
		fontSize?: number;
		position?: "top-left" | "top" | "top-right" | "bottom-left" | "bottom" | "bottom-right";
	}): Promise<Disposable>;
	hideActions(): Promise<void>;
}

`AccessibilityEvents`#

class AccessibilityEvents {
	on(type: AccessibilityEvent, listener: AccessibilityListener): this;
	once(type: AccessibilityEvent, listener: AccessibilityListener): this;
	off(type: AccessibilityEvent, listener: AccessibilityListener): this;
	addListener(type: AccessibilityEvent, listener: AccessibilityListener): this;
	removeListener(type: AccessibilityEvent, listener: AccessibilityListener): this;
	waitForEvent(type: AccessibilityEvent, optionsOrPredicate?: {
		predicate?: (target: ComputerLocator | null, text?: string) => boolean | Promise<boolean>;
		timeout?: number;
		signal?: AbortSignal;
	} | ((target: ComputerLocator | null, text?: string) => boolean | Promise<boolean>)): Promise<ComputerLocator | null>;
}

`ComputerWindow`#

class ComputerWindow {
	readonly app: App;
	readonly id: string;
	readonly kind: WindowKind;
	readonly mouse: Mouse;
	readonly keyboard: Keyboard;
	readonly screencast: Screencast;
	readonly accessibility: AccessibilityEvents;
	title(): Promise<string>;
	isClosed(): boolean;
	opener(): Promise<ComputerWindow | null>;
	bounds(): Promise<ComputerRect>;
	setBounds(rect: Partial<ComputerRect>): Promise<void>;
	scale(): Promise<number>;
	isForeground(): Promise<boolean>;
	bringToFront(): Promise<void>;
	isForegroundForUser(): Promise<boolean>;
	bringToFrontForUser(): Promise<void>;
	isMinimized(): Promise<boolean>;
	minimize(): Promise<void>;
	restore(): Promise<void>;
	isMaximized(): Promise<boolean>;
	maximize(): Promise<void>;
	unmaximize(): Promise<void>;
	close(options?: {
		reason?: string;
	}): Promise<void>;
	waitForIdle(options?: SignalTimeoutOptions): Promise<void>;
	setDefaultTimeout(timeout: number): void;
	locator(selector: string, options?: LocatorOptions): ComputerLocator;
	getByRole(role: AriaRole, options?: ByRoleOptions): ComputerLocator;
	getByAltText(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByText(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByLabel(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByPlaceholder(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByTitle(text: TextMatcher, options?: {
		exact?: boolean;
	}): ComputerLocator;
	getByTestId(testId: TextMatcher): ComputerLocator;
	ariaSnapshot(options?: SnapshotOptions): Promise<string>;
	ariaSnapshotJSON(options?: SnapshotOptions): Promise<Serializable>;
	screenshot(options?: ScreenshotOptions): Promise<Buffer>;
	check(selector: string, options?: CheckOptions & {
		strict?: boolean;
	}): Promise<void>;
	click(selector: string, options?: PointerActionOptions & {
		strict?: boolean;
	}): Promise<void>;
	dblclick(selector: string, options?: PointerActionOptions & {
		strict?: boolean;
	}): Promise<void>;
	dragAndDrop(source: string, target: string, options?: DragOptions & {
		strict?: boolean;
	}): Promise<void>;
	fill(selector: string, value: string, options?: ForceOptions & {
		strict?: boolean;
	}): Promise<void>;
	focus(selector: string, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<void>;
	getAttribute(selector: string, name: string, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<string | null>;
	hover(selector: string, options?: PointerActionOptions & {
		strict?: boolean;
	}): Promise<void>;
	innerText(selector: string, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<string>;
	inputValue(selector: string, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<string>;
	isChecked(selector: string, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<boolean>;
	isDisabled(selector: string, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<boolean>;
	isEditable(selector: string, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<boolean>;
	isEnabled(selector: string, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<boolean>;
	isHidden(selector: string, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<boolean>;
	isVisible(selector: string, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<boolean>;
	press(selector: string, key: string, options?: KeyOptions & {
		strict?: boolean;
	}): Promise<void>;
	selectOption(selector: string, values: SelectOptionValue, options?: ForceOptions & {
		strict?: boolean;
	}): Promise<string[]>;
	setChecked(selector: string, checked: boolean, options?: CheckOptions & {
		strict?: boolean;
	}): Promise<void>;
	setInputFiles(selector: string, files: string | ReadonlyArray<string>, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<void>;
	textContent(selector: string, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<string | null>;
	uncheck(selector: string, options?: CheckOptions & {
		strict?: boolean;
	}): Promise<void>;
	performAction(selector: string, action: string, options?: SignalTimeoutOptions & {
		strict?: boolean;
	}): Promise<void>;
	on<Event extends keyof WindowEventMap>(event: Event, listener: (...args: WindowEventMap[Event]) => unknown): this;
	once<Event extends keyof WindowEventMap>(event: Event, listener: (...args: WindowEventMap[Event]) => unknown): this;
	off<Event extends keyof WindowEventMap>(event: Event, listener: (...args: WindowEventMap[Event]) => unknown): this;
	addListener<Event extends keyof WindowEventMap>(event: Event, listener: (...args: WindowEventMap[Event]) => unknown): this;
	removeListener<Event extends keyof WindowEventMap>(event: Event, listener: (...args: WindowEventMap[Event]) => unknown): this;
	waitForEvent<Event extends keyof WindowEventMap>(event: Event, optionsOrPredicate?: {
		predicate?: (...args: WindowEventMap[Event]) => boolean | Promise<boolean>;
		timeout?: number;
		signal?: AbortSignal;
	} | ((...args: WindowEventMap[Event]) => boolean | Promise<boolean>)): Promise<EventResult<WindowEventMap[Event]>>;
}

`TextMatcher`#

type TextMatcher = string | RegExp;

`WindowKind`#

type WindowKind = "window" | "dialog" | "sheet" | "popover" | "menu";

`LocatorOptions`#

type LocatorOptions = {
	has?: ComputerLocator;
	hasNot?: ComputerLocator;
	hasText?: TextMatcher;
	hasNotText?: TextMatcher;
};

`AriaRole`#

type AriaRole = "alert" | "alertdialog" | "application" | "article" | "banner" | "blockquote" | "button" | "caption" | "cell" | "checkbox" | "code" | "columnheader" | "combobox" | "complementary" | "contentinfo" | "definition" | "deletion" | "dialog" | "directory" | "document" | "emphasis" | "feed" | "figure" | "form" | "generic" | "grid" | "gridcell" | "group" | "heading" | "img" | "insertion" | "link" | "list" | "listbox" | "listitem" | "log" | "main" | "marquee" | "math" | "meter" | "menu" | "menubar" | "menuitem" | "menuitemcheckbox" | "menuitemradio" | "navigation" | "none" | "note" | "option" | "paragraph" | "presentation" | "progressbar" | "radio" | "radiogroup" | "region" | "row" | "rowgroup" | "rowheader" | "scrollbar" | "search" | "searchbox" | "separator" | "slider" | "spinbutton" | "status" | "strong" | "subscript" | "superscript" | "switch" | "tab" | "table" | "tablist" | "tabpanel" | "term" | "textbox" | "time" | "timer" | "toolbar" | "tooltip" | "tree" | "treegrid" | "treeitem" | "window";

`ByRoleOptions`#

type ByRoleOptions = {
	checked?: boolean;
	description?: TextMatcher;
	disabled?: boolean;
	exact?: boolean;
	expanded?: boolean;
	includeHidden?: boolean;
	level?: number;
	name?: TextMatcher;
	pressed?: boolean;
	selected?: boolean;
};

`SnapshotOptions`#

type SnapshotOptions = SignalTimeoutOptions & {
	boxes?: boolean;
	depth?: number;
	mode?: "ai" | "default";
};

`Serializable`#

type Serializable = any;

`ScreenshotOptions`#

type ScreenshotOptions = SignalTimeoutOptions & {
	clip?: ComputerRect;
	mask?: ComputerLocator[];
	maskColor?: string;
	omitBackground?: boolean;
	path?: string;
	quality?: number;
	type?: "png" | "jpeg";
	scale?: "css" | "device";
	refs?: false | "interactive" | "all";
};

`AppEventMap`#

type AppEventMap = {
	window: [
		window: ComputerWindow
	];
	close: [
	];
	foreground: [
	];
	background: [
	];
	foregroundForUser: [
	];
	backgroundForUser: [
	];
};

`EventResult`#

type EventResult<Arguments extends unknown[]> = Arguments extends [
	infer Value,
	...unknown[]
] ? Value : void;

`ComputerRect`#

type ComputerRect = {
	x: number;
	y: number;
	width: number;
	height: number;
};

`PermissionState`#

type PermissionState = "granted" | "denied" | "notDetermined";

`LocatorFilterOptions`#

type LocatorFilterOptions = LocatorOptions & {
	visible?: boolean;
};

`PointerActionOptions`#

type PointerActionOptions = SignalTimeoutOptions & {
	button?: "left" | "right" | "middle";
	clickCount?: number;
	delay?: number;
	force?: boolean;
	modifiers?: ComputerModifier[];
	position?: Position;
	scroll?: "auto" | "none";
	steps?: number;
	trial?: boolean;
};

`DragOptions`#

type DragOptions = SignalTimeoutOptions & {
	force?: boolean;
	scroll?: "auto" | "none";
	sourcePosition?: Position;
	steps?: number;
	targetPosition?: Position;
	trial?: boolean;
};

`ForceOptions`#

type ForceOptions = SignalTimeoutOptions & {
	force?: boolean;
};

`KeyOptions`#

type KeyOptions = SignalTimeoutOptions & {
	delay?: number;
};

`CheckOptions`#

type CheckOptions = ForceOptions & {
	position?: Position;
	scroll?: "auto" | "none";
	trial?: boolean;
};

`SelectOptionValue`#

type SelectOptionValue = null | string | ReadonlyArray<string> | {
	value?: string;
	label?: string;
	index?: number;
} | ReadonlyArray<{
	value?: string;
	label?: string;
	index?: number;
}>;

`WaitForOptions`#

type WaitForOptions = SignalTimeoutOptions & {
	state?: "attached" | "detached" | "visible" | "hidden";
};

`ScreencastFrame`#

type ScreencastFrame = {
	data: Buffer;
	timestamp: number;
	keyframe: boolean;
	viewportWidth: number;
	viewportHeight: number;
};

`Disposable`#

interface Disposable {
	[Symbol.dispose](): void;
}

`AccessibilityEvent`#

type AccessibilityEvent = "focus" | "value" | "text" | "selection" | "structure" | "menu" | "announcement" | "busy";

`AccessibilityListener`#

type AccessibilityListener = (target: ComputerLocator | null, text?: string) => unknown;

`WindowEventMap`#

type WindowEventMap = {
	close: [
		window: ComputerWindow
	];
	popup: [
		popup: ComputerWindow
	];
	filechooser: [
		fileChooser: ComputerFileChooser
	];
	foreground: [
		window: ComputerWindow
	];
	background: [
		window: ComputerWindow
	];
	foregroundForUser: [
		window: ComputerWindow
	];
	backgroundForUser: [
		window: ComputerWindow
	];
	minimize: [
		window: ComputerWindow
	];
	restore: [
		window: ComputerWindow
	];
	maximize: [
		window: ComputerWindow
	];
	unmaximize: [
		window: ComputerWindow
	];
};

`ComputerModifier`#

type ComputerModifier = "Alt" | "Control" | "ControlOrMeta" | "Meta" | "Shift";

`Position`#

type Position = {
	x: number;
	y: number;
};

`ComputerFileChooser`#

class ComputerFileChooser {
	window(): ComputerWindow;
	panel(): ComputerWindow;
	element(): ComputerLocator;
	isMultiple(): boolean;
	setFiles(files: string | ReadonlyArray<string>, options?: {
		noWaitAfter?: boolean;
		signal?: AbortSignal;
		timeout?: number;
	}): Promise<void>;
}

Mac apps API

Types#

Computer#

TimeoutError#

StrictModeError#

TargetClosedError#

AppNotFoundError#

PermissionDeniedError#

ActionNotSupportedError#

ModalOpenError#

CancelledError#

SessionLockedError#

Shell#

Keyboard#

Mouse#

Clipboard#

App#

SignalTimeoutOptions#

Display#

Session#

Permissions#

ComputerLocator#

ClipboardContent#

Screencast#

AccessibilityEvents#

ComputerWindow#

TextMatcher#

WindowKind#

LocatorOptions#

AriaRole#

ByRoleOptions#

SnapshotOptions#

Serializable#

ScreenshotOptions#

AppEventMap#

EventResult#

ComputerRect#

PermissionState#

LocatorFilterOptions#

PointerActionOptions#

DragOptions#

ForceOptions#

KeyOptions#

CheckOptions#

SelectOptionValue#

WaitForOptions#

ScreencastFrame#

Disposable#

AccessibilityEvent#

AccessibilityListener#

WindowEventMap#

ComputerModifier#

Position#

ComputerFileChooser#