Bridge

The generated section below is sourced from runtime/types/bridge.d.ts.

Generated Bridge Declarations

setTimeout

export declare function setTimeout(
	callback: (...args: unknown[]) => void,
	ms: number,
): unknown;

clearTimeout

export declare function clearTimeout(timerID: unknown): void;

setInterval

export declare function setInterval(
	callback: (...args: unknown[]) => void,
	ms: number,
): unknown;

sleep

export declare function sleep(ms: number): Promise<void>;

clearInterval

export declare function clearInterval(timerID: unknown): void;

print

export declare function print(...args: unknown[]): void;

compare

Returns whether two acyclic Encodable values are equal. Records compare their own enumerable string keys, ignoring key order and distinguishing missing keys from undefined values. Arrays compare their length and elements in order; empty slots are treated as undefined. Primitive values use strict equality, except that NaN equals NaN.

export declare function compare(lhs: Encodable, rhs: Encodable): boolean;

console

export declare const console: {
	log(...args: unknown[]): void;
};

AwaitClipboard

export declare const AwaitClipboard: {
	set(value: string): void;
};

AwaitNetwork

export declare const AwaitNetwork: {
	request(
		urlString: string,
		config?: AwaitNetworkConfig,
	): Promise<AwaitNetworkResponse>;
	fanfou(urlString: string, config?: AwaitFoufouConfig): Promise<unknown>;
};

AwaitWeather

export declare const AwaitWeather: {
	get(config?: AwaitWeatherConfig): Promise<AwaitWeatherResult | undefined>;
};

AwaitHealth

export declare const AwaitHealth: {
	get(): Promise<AwaitHealthInfo | undefined>;
	get(config: AwaitHealthConfig): Promise<AwaitHealthRangeInfo | undefined>;
};

AwaitLocation

export declare const AwaitLocation: {
	get(config?: AwaitLocationConfig): Promise<AwaitLocationInfo | undefined>;
};

AwaitCalendar

export declare const AwaitCalendar: {
	get(config?: AwaitCalendarConfig): Promise<AwaitCalendarItem[] | undefined>;
};

AwaitReminder

export declare const AwaitReminder: {
	get(config?: AwaitReminderConfig): Promise<AwaitReminderItem[] | undefined>;
	set(
		id: string,
		config: {
			completed: boolean;
		},
	): Promise<void>;
};

AwaitSystem

export declare const AwaitSystem: {
	get(): AwaitSystemInfo;
};

AwaitAlarm

export declare const AwaitAlarm: {
	schedule(config: AwaitAlarmScheduleConfig): Promise<string>;
	cancel(id: string): any;
};

AwaitMusic

export declare const AwaitMusic: {
	nowPlaying(config?: AwaitNowPlayingConfig): Promise<AwaitNowPlayingInfo>;
	playerCommand(
		command: AwaitMusicPlayerCommand,
		config?: AwaitMusicPlayConfig,
	): Promise<void>;
};

AwaitStore

export declare const AwaitStore: {
	get<T>(key: string): T | undefined;
	num(key: string, defaultValue?: number): number;
	bool(key: string, defaultValue?: boolean): boolean;
	string(key: string, defaultValue?: string): string;
	array<T>(key: string, defaultValue?: T[]): T[];
	delete(key: string): void;
	set(key: string, value: Encodable): void;
};

AwaitFile

AwaitFile can interact only with files located within the widget directory. Do not access hidden paths or parent directories.

export declare const AwaitFile: {
	files(path: string): string[];
	readJSON(path: string): unknown;
	readText(path: string): string | undefined;
	fileSize(path: string): number | undefined;
	readTextByPage(
		path: string,
		page: number,
		pageSize: number,
	): string | undefined;
	readTextByPages(
		path: string,
		pages: number[],
		pageSize: number,
	): Array<string | undefined>;
	renderText(
		path: string,
		request: TextRenderRequest,
		layout: TextRenderLayout,
	): TextRenderResult | undefined;
	renderTexts(
		path: string,
		requests: TextRenderRequest[],
		layout: TextRenderLayout,
	): Array<TextRenderResult | undefined> | undefined;
	saveUIRenderImage(path: string, value: NativeView): void;
};

AwaitAudio

export declare const AwaitAudio: {
	readonly isPlayingNote: boolean;
	setAudioSession(active: boolean, option?: AudioOption): void;
	reinstallInstruments(): void;
	playAudio(url: string, config?: AudioConfig): void;
	pauseAudio(): void;
	playMidi(url: string, config?: AudioConfig): void;
	stopMidi(): void;
	replayMidi(config?: AudioConfig): void;
	recordMidi(): void;
	buildSoundFont(config: SoundFontBuildConfig): Promise<SoundFontBuildResult>;
	compressSoundFont(
		config: SoundFontCompressConfig,
	): Promise<SoundFontBuildResult>;
	playNote(notes: number[] | number, config?: AudioConfig): void;
};

AwaitUI

export declare const AwaitUI: {
	readonly displayScale: number;
	haptic(type: string): void;
	goHome(): void;
};

Await

export declare const Await: {
	define<T extends Record<string, unknown>, Config extends AwaitDefineShape>(
		config: Config & AwaitDefineConfig<T, Config['widgetIntents']>,
	): AwaitDefineResult<Config['widgetIntents']>;
};

AwaitLive

export declare const AwaitLive: {
	start(views: LiveViews): Promise<void>;
	end(): Promise<void>;
	toggle(views: LiveViews): Promise<void>;
};

AwaitLaunch

export declare const AwaitLaunch: {
	start(bundleId: string): any;
};

AwaitEnv

export declare const AwaitEnv: {
	readonly id: string;
	readonly tag: number;
	readonly host: 'app' | 'widget';
	readonly language: string;
	readonly version: string;
	readonly appVersion: string;
	test(...args: unknown[]): unknown;
};

Generated Bridge Helper Types

AwaitNetworkResponse

type AwaitNetworkResponse = {
	code: number;
	data: string;
};

AwaitNetworkConfig

type AwaitNetworkConfig = {
	method?: string;
	headers?: Record<string, string>;
	body?: Encodable;
};

AwaitFoufouConfig

type AwaitFoufouConfig = {
	method?: string;
	image?: string;
	oauthToken?: string;
	oauthTokenSecret?: string;
	consumerKey?: string;
	consumerSecret?: string;
	username?: string;
	password?: string;
	parameters?: Record<string, string | number | boolean>;
};

AwaitDefineConfig

type AwaitDefineConfig<T extends Record<string, unknown>, Intents> = {
	widget: (entry: WidgetEntry<T>) => NativeView;
	widgetTimeline?: (
		context: TimelineContext,
	) => Timeline<T> | Promise<Timeline<T>>;
	widgetFamilies?: WidgetFamily[];
	autoAccented?: boolean;
	widgetIntents?: {
		[IntentKey in keyof Intents]: Intents[IntentKey] extends (
			...args: infer IntentArguments
		) => void
			? IntentArguments extends Encodable[]
				? Intents[IntentKey]
				: never
			: never;
	};
};

AwaitDefineResult

type AwaitDefineResult<Intents> = {
	[IntentKey in keyof Intents]: Intents[IntentKey] extends (
		...args: infer IntentArguments
	) => void
		? (...args: IntentArguments) => IntentInfo
		: never;
};

AwaitDefineShape

type AwaitDefineShape = {
	widgetIntents?: Record<string, (...args: any[]) => void>;
};

AwaitGlobal

type AwaitGlobal = typeof Await;

AwaitEnvGlobal

type AwaitEnvGlobal = typeof AwaitEnv;

AwaitLiveGlobal

type AwaitLiveGlobal = typeof AwaitLive;

AwaitLaunchGlobal

type AwaitLaunchGlobal = typeof AwaitLaunch;

AwaitUIGlobal

type AwaitUIGlobal = typeof AwaitUI;

AwaitClipboardGlobal

type AwaitClipboardGlobal = typeof AwaitClipboard;

AwaitNetworkGlobal

type AwaitNetworkGlobal = typeof AwaitNetwork;

AwaitWeatherGlobal

type AwaitWeatherGlobal = typeof AwaitWeather;

AwaitHealthGlobal

type AwaitHealthGlobal = typeof AwaitHealth;

AwaitLocationGlobal

type AwaitLocationGlobal = typeof AwaitLocation;

AwaitCalendarGlobal

type AwaitCalendarGlobal = typeof AwaitCalendar;

AwaitReminderGlobal

type AwaitReminderGlobal = typeof AwaitReminder;

AwaitSystemGlobal

type AwaitSystemGlobal = typeof AwaitSystem;

AwaitAlarmGlobal

type AwaitAlarmGlobal = typeof AwaitAlarm;

AwaitMusicGlobal

type AwaitMusicGlobal = typeof AwaitMusic;

AwaitStoreGlobal

type AwaitStoreGlobal = typeof AwaitStore;

AwaitFileGlobal

type AwaitFileGlobal = typeof AwaitFile;

AwaitAudioGlobal

type AwaitAudioGlobal = typeof AwaitAudio;

SleepGlobal

type SleepGlobal = typeof sleep;