@wailsio/runtime 3.0.0-alpha.9 → 3.0.0-alpha.94

package/types/event_types.d.ts

@@ -0,0 +1,281 @@
+export declare const Types: Readonly<{
+    Windows: Readonly<{
+        APMPowerSettingChange: "windows:APMPowerSettingChange";
+        APMPowerStatusChange: "windows:APMPowerStatusChange";
+        APMResumeAutomatic: "windows:APMResumeAutomatic";
+        APMResumeSuspend: "windows:APMResumeSuspend";
+        APMSuspend: "windows:APMSuspend";
+        ApplicationStarted: "windows:ApplicationStarted";
+        SystemThemeChanged: "windows:SystemThemeChanged";
+        WebViewNavigationCompleted: "windows:WebViewNavigationCompleted";
+        WindowActive: "windows:WindowActive";
+        WindowBackgroundErase: "windows:WindowBackgroundErase";
+        WindowClickActive: "windows:WindowClickActive";
+        WindowClosing: "windows:WindowClosing";
+        WindowDidMove: "windows:WindowDidMove";
+        WindowDidResize: "windows:WindowDidResize";
+        WindowDPIChanged: "windows:WindowDPIChanged";
+        WindowDragDrop: "windows:WindowDragDrop";
+        WindowDragEnter: "windows:WindowDragEnter";
+        WindowDragLeave: "windows:WindowDragLeave";
+        WindowDragOver: "windows:WindowDragOver";
+        WindowEndMove: "windows:WindowEndMove";
+        WindowEndResize: "windows:WindowEndResize";
+        WindowFullscreen: "windows:WindowFullscreen";
+        WindowHide: "windows:WindowHide";
+        WindowInactive: "windows:WindowInactive";
+        WindowKeyDown: "windows:WindowKeyDown";
+        WindowKeyUp: "windows:WindowKeyUp";
+        WindowKillFocus: "windows:WindowKillFocus";
+        WindowNonClientHit: "windows:WindowNonClientHit";
+        WindowNonClientMouseDown: "windows:WindowNonClientMouseDown";
+        WindowNonClientMouseLeave: "windows:WindowNonClientMouseLeave";
+        WindowNonClientMouseMove: "windows:WindowNonClientMouseMove";
+        WindowNonClientMouseUp: "windows:WindowNonClientMouseUp";
+        WindowPaint: "windows:WindowPaint";
+        WindowRestore: "windows:WindowRestore";
+        WindowSetFocus: "windows:WindowSetFocus";
+        WindowShow: "windows:WindowShow";
+        WindowStartMove: "windows:WindowStartMove";
+        WindowStartResize: "windows:WindowStartResize";
+        WindowUnFullscreen: "windows:WindowUnFullscreen";
+        WindowZOrderChanged: "windows:WindowZOrderChanged";
+        WindowMinimise: "windows:WindowMinimise";
+        WindowUnMinimise: "windows:WindowUnMinimise";
+        WindowMaximise: "windows:WindowMaximise";
+        WindowUnMaximise: "windows:WindowUnMaximise";
+    }>;
+    Mac: Readonly<{
+        ApplicationDidBecomeActive: "mac:ApplicationDidBecomeActive";
+        ApplicationDidChangeBackingProperties: "mac:ApplicationDidChangeBackingProperties";
+        ApplicationDidChangeEffectiveAppearance: "mac:ApplicationDidChangeEffectiveAppearance";
+        ApplicationDidChangeIcon: "mac:ApplicationDidChangeIcon";
+        ApplicationDidChangeOcclusionState: "mac:ApplicationDidChangeOcclusionState";
+        ApplicationDidChangeScreenParameters: "mac:ApplicationDidChangeScreenParameters";
+        ApplicationDidChangeStatusBarFrame: "mac:ApplicationDidChangeStatusBarFrame";
+        ApplicationDidChangeStatusBarOrientation: "mac:ApplicationDidChangeStatusBarOrientation";
+        ApplicationDidChangeTheme: "mac:ApplicationDidChangeTheme";
+        ApplicationDidFinishLaunching: "mac:ApplicationDidFinishLaunching";
+        ApplicationDidHide: "mac:ApplicationDidHide";
+        ApplicationDidResignActive: "mac:ApplicationDidResignActive";
+        ApplicationDidUnhide: "mac:ApplicationDidUnhide";
+        ApplicationDidUpdate: "mac:ApplicationDidUpdate";
+        ApplicationDidWake: "mac:ApplicationDidWake";
+        ApplicationScreensDidSleep: "mac:ApplicationScreensDidSleep";
+        ApplicationScreensDidWake: "mac:ApplicationScreensDidWake";
+        ApplicationShouldHandleReopen: "mac:ApplicationShouldHandleReopen";
+        ApplicationWillBecomeActive: "mac:ApplicationWillBecomeActive";
+        ApplicationWillFinishLaunching: "mac:ApplicationWillFinishLaunching";
+        ApplicationWillHide: "mac:ApplicationWillHide";
+        ApplicationWillResignActive: "mac:ApplicationWillResignActive";
+        ApplicationWillSleep: "mac:ApplicationWillSleep";
+        ApplicationWillTerminate: "mac:ApplicationWillTerminate";
+        ApplicationWillUnhide: "mac:ApplicationWillUnhide";
+        ApplicationWillUpdate: "mac:ApplicationWillUpdate";
+        MenuDidAddItem: "mac:MenuDidAddItem";
+        MenuDidBeginTracking: "mac:MenuDidBeginTracking";
+        MenuDidClose: "mac:MenuDidClose";
+        MenuDidDisplayItem: "mac:MenuDidDisplayItem";
+        MenuDidEndTracking: "mac:MenuDidEndTracking";
+        MenuDidHighlightItem: "mac:MenuDidHighlightItem";
+        MenuDidOpen: "mac:MenuDidOpen";
+        MenuDidPopUp: "mac:MenuDidPopUp";
+        MenuDidRemoveItem: "mac:MenuDidRemoveItem";
+        MenuDidSendAction: "mac:MenuDidSendAction";
+        MenuDidSendActionToItem: "mac:MenuDidSendActionToItem";
+        MenuDidUpdate: "mac:MenuDidUpdate";
+        MenuWillAddItem: "mac:MenuWillAddItem";
+        MenuWillBeginTracking: "mac:MenuWillBeginTracking";
+        MenuWillDisplayItem: "mac:MenuWillDisplayItem";
+        MenuWillEndTracking: "mac:MenuWillEndTracking";
+        MenuWillHighlightItem: "mac:MenuWillHighlightItem";
+        MenuWillOpen: "mac:MenuWillOpen";
+        MenuWillPopUp: "mac:MenuWillPopUp";
+        MenuWillRemoveItem: "mac:MenuWillRemoveItem";
+        MenuWillSendAction: "mac:MenuWillSendAction";
+        MenuWillSendActionToItem: "mac:MenuWillSendActionToItem";
+        MenuWillUpdate: "mac:MenuWillUpdate";
+        WebViewDidCommitNavigation: "mac:WebViewDidCommitNavigation";
+        WebViewDidFinishNavigation: "mac:WebViewDidFinishNavigation";
+        WebViewDidReceiveServerRedirectForProvisionalNavigation: "mac:WebViewDidReceiveServerRedirectForProvisionalNavigation";
+        WebViewDidStartProvisionalNavigation: "mac:WebViewDidStartProvisionalNavigation";
+        WindowDidBecomeKey: "mac:WindowDidBecomeKey";
+        WindowDidBecomeMain: "mac:WindowDidBecomeMain";
+        WindowDidBeginSheet: "mac:WindowDidBeginSheet";
+        WindowDidChangeAlpha: "mac:WindowDidChangeAlpha";
+        WindowDidChangeBackingLocation: "mac:WindowDidChangeBackingLocation";
+        WindowDidChangeBackingProperties: "mac:WindowDidChangeBackingProperties";
+        WindowDidChangeCollectionBehavior: "mac:WindowDidChangeCollectionBehavior";
+        WindowDidChangeEffectiveAppearance: "mac:WindowDidChangeEffectiveAppearance";
+        WindowDidChangeOcclusionState: "mac:WindowDidChangeOcclusionState";
+        WindowDidChangeOrderingMode: "mac:WindowDidChangeOrderingMode";
+        WindowDidChangeScreen: "mac:WindowDidChangeScreen";
+        WindowDidChangeScreenParameters: "mac:WindowDidChangeScreenParameters";
+        WindowDidChangeScreenProfile: "mac:WindowDidChangeScreenProfile";
+        WindowDidChangeScreenSpace: "mac:WindowDidChangeScreenSpace";
+        WindowDidChangeScreenSpaceProperties: "mac:WindowDidChangeScreenSpaceProperties";
+        WindowDidChangeSharingType: "mac:WindowDidChangeSharingType";
+        WindowDidChangeSpace: "mac:WindowDidChangeSpace";
+        WindowDidChangeSpaceOrderingMode: "mac:WindowDidChangeSpaceOrderingMode";
+        WindowDidChangeTitle: "mac:WindowDidChangeTitle";
+        WindowDidChangeToolbar: "mac:WindowDidChangeToolbar";
+        WindowDidDeminiaturize: "mac:WindowDidDeminiaturize";
+        WindowDidEndSheet: "mac:WindowDidEndSheet";
+        WindowDidEnterFullScreen: "mac:WindowDidEnterFullScreen";
+        WindowDidEnterVersionBrowser: "mac:WindowDidEnterVersionBrowser";
+        WindowDidExitFullScreen: "mac:WindowDidExitFullScreen";
+        WindowDidExitVersionBrowser: "mac:WindowDidExitVersionBrowser";
+        WindowDidExpose: "mac:WindowDidExpose";
+        WindowDidFocus: "mac:WindowDidFocus";
+        WindowDidMiniaturize: "mac:WindowDidMiniaturize";
+        WindowDidMove: "mac:WindowDidMove";
+        WindowDidOrderOffScreen: "mac:WindowDidOrderOffScreen";
+        WindowDidOrderOnScreen: "mac:WindowDidOrderOnScreen";
+        WindowDidResignKey: "mac:WindowDidResignKey";
+        WindowDidResignMain: "mac:WindowDidResignMain";
+        WindowDidResize: "mac:WindowDidResize";
+        WindowDidUpdate: "mac:WindowDidUpdate";
+        WindowDidUpdateAlpha: "mac:WindowDidUpdateAlpha";
+        WindowDidUpdateCollectionBehavior: "mac:WindowDidUpdateCollectionBehavior";
+        WindowDidUpdateCollectionProperties: "mac:WindowDidUpdateCollectionProperties";
+        WindowDidUpdateShadow: "mac:WindowDidUpdateShadow";
+        WindowDidUpdateTitle: "mac:WindowDidUpdateTitle";
+        WindowDidUpdateToolbar: "mac:WindowDidUpdateToolbar";
+        WindowDidZoom: "mac:WindowDidZoom";
+        WindowFileDraggingEntered: "mac:WindowFileDraggingEntered";
+        WindowFileDraggingExited: "mac:WindowFileDraggingExited";
+        WindowFileDraggingPerformed: "mac:WindowFileDraggingPerformed";
+        WindowHide: "mac:WindowHide";
+        WindowMaximise: "mac:WindowMaximise";
+        WindowUnMaximise: "mac:WindowUnMaximise";
+        WindowMinimise: "mac:WindowMinimise";
+        WindowUnMinimise: "mac:WindowUnMinimise";
+        WindowShouldClose: "mac:WindowShouldClose";
+        WindowShow: "mac:WindowShow";
+        WindowWillBecomeKey: "mac:WindowWillBecomeKey";
+        WindowWillBecomeMain: "mac:WindowWillBecomeMain";
+        WindowWillBeginSheet: "mac:WindowWillBeginSheet";
+        WindowWillChangeOrderingMode: "mac:WindowWillChangeOrderingMode";
+        WindowWillClose: "mac:WindowWillClose";
+        WindowWillDeminiaturize: "mac:WindowWillDeminiaturize";
+        WindowWillEnterFullScreen: "mac:WindowWillEnterFullScreen";
+        WindowWillEnterVersionBrowser: "mac:WindowWillEnterVersionBrowser";
+        WindowWillExitFullScreen: "mac:WindowWillExitFullScreen";
+        WindowWillExitVersionBrowser: "mac:WindowWillExitVersionBrowser";
+        WindowWillFocus: "mac:WindowWillFocus";
+        WindowWillMiniaturize: "mac:WindowWillMiniaturize";
+        WindowWillMove: "mac:WindowWillMove";
+        WindowWillOrderOffScreen: "mac:WindowWillOrderOffScreen";
+        WindowWillOrderOnScreen: "mac:WindowWillOrderOnScreen";
+        WindowWillResignMain: "mac:WindowWillResignMain";
+        WindowWillResize: "mac:WindowWillResize";
+        WindowWillUnfocus: "mac:WindowWillUnfocus";
+        WindowWillUpdate: "mac:WindowWillUpdate";
+        WindowWillUpdateAlpha: "mac:WindowWillUpdateAlpha";
+        WindowWillUpdateCollectionBehavior: "mac:WindowWillUpdateCollectionBehavior";
+        WindowWillUpdateCollectionProperties: "mac:WindowWillUpdateCollectionProperties";
+        WindowWillUpdateShadow: "mac:WindowWillUpdateShadow";
+        WindowWillUpdateTitle: "mac:WindowWillUpdateTitle";
+        WindowWillUpdateToolbar: "mac:WindowWillUpdateToolbar";
+        WindowWillUpdateVisibility: "mac:WindowWillUpdateVisibility";
+        WindowWillUseStandardFrame: "mac:WindowWillUseStandardFrame";
+        WindowZoomIn: "mac:WindowZoomIn";
+        WindowZoomOut: "mac:WindowZoomOut";
+        WindowZoomReset: "mac:WindowZoomReset";
+    }>;
+    Linux: Readonly<{
+        ApplicationStartup: "linux:ApplicationStartup";
+        SystemDidWake: "linux:SystemDidWake";
+        SystemThemeChanged: "linux:SystemThemeChanged";
+        SystemWillSleep: "linux:SystemWillSleep";
+        WindowDeleteEvent: "linux:WindowDeleteEvent";
+        WindowDidMove: "linux:WindowDidMove";
+        WindowDidResize: "linux:WindowDidResize";
+        WindowFocusIn: "linux:WindowFocusIn";
+        WindowFocusOut: "linux:WindowFocusOut";
+        WindowLoadStarted: "linux:WindowLoadStarted";
+        WindowLoadRedirected: "linux:WindowLoadRedirected";
+        WindowLoadCommitted: "linux:WindowLoadCommitted";
+        WindowLoadFinished: "linux:WindowLoadFinished";
+    }>;
+    iOS: Readonly<{
+        ApplicationDidBecomeActive: "ios:ApplicationDidBecomeActive";
+        ApplicationDidEnterBackground: "ios:ApplicationDidEnterBackground";
+        ApplicationDidFinishLaunching: "ios:ApplicationDidFinishLaunching";
+        ApplicationDidReceiveMemoryWarning: "ios:ApplicationDidReceiveMemoryWarning";
+        ApplicationWillEnterForeground: "ios:ApplicationWillEnterForeground";
+        ApplicationWillResignActive: "ios:ApplicationWillResignActive";
+        ApplicationWillTerminate: "ios:ApplicationWillTerminate";
+        WindowDidLoad: "ios:WindowDidLoad";
+        WindowWillAppear: "ios:WindowWillAppear";
+        WindowDidAppear: "ios:WindowDidAppear";
+        WindowWillDisappear: "ios:WindowWillDisappear";
+        WindowDidDisappear: "ios:WindowDidDisappear";
+        WindowSafeAreaInsetsChanged: "ios:WindowSafeAreaInsetsChanged";
+        WindowOrientationChanged: "ios:WindowOrientationChanged";
+        WindowTouchBegan: "ios:WindowTouchBegan";
+        WindowTouchMoved: "ios:WindowTouchMoved";
+        WindowTouchEnded: "ios:WindowTouchEnded";
+        WindowTouchCancelled: "ios:WindowTouchCancelled";
+        WebViewDidStartNavigation: "ios:WebViewDidStartNavigation";
+        WebViewDidFinishNavigation: "ios:WebViewDidFinishNavigation";
+        WebViewDidFailNavigation: "ios:WebViewDidFailNavigation";
+        WebViewDecidePolicyForNavigationAction: "ios:WebViewDecidePolicyForNavigationAction";
+        BatteryChanged: "ios:BatteryChanged";
+        NetworkChanged: "ios:NetworkChanged";
+        ThemeChanged: "ios:ThemeChanged";
+        ScreenLocked: "ios:ScreenLocked";
+        ScreenUnlocked: "ios:ScreenUnlocked";
+    }>;
+    Android: Readonly<{
+        ActivityCreated: "android:ActivityCreated";
+        ActivityStarted: "android:ActivityStarted";
+        ActivityResumed: "android:ActivityResumed";
+        ActivityPaused: "android:ActivityPaused";
+        ActivityStopped: "android:ActivityStopped";
+        ActivityDestroyed: "android:ActivityDestroyed";
+        ApplicationLowMemory: "android:ApplicationLowMemory";
+        WebViewPageStarted: "android:WebViewPageStarted";
+        WebViewPageFinished: "android:WebViewPageFinished";
+        BatteryChanged: "android:BatteryChanged";
+        NetworkChanged: "android:NetworkChanged";
+        ThemeChanged: "android:ThemeChanged";
+        ScreenLocked: "android:ScreenLocked";
+        ScreenUnlocked: "android:ScreenUnlocked";
+    }>;
+    Common: Readonly<{
+        ApplicationOpenedWithFile: "common:ApplicationOpenedWithFile";
+        ApplicationStarted: "common:ApplicationStarted";
+        ApplicationLaunchedWithUrl: "common:ApplicationLaunchedWithUrl";
+        ThemeChanged: "common:ThemeChanged";
+        SystemDidWake: "common:SystemDidWake";
+        SystemWillSleep: "common:SystemWillSleep";
+        WindowClosing: "common:WindowClosing";
+        WindowDidMove: "common:WindowDidMove";
+        WindowDidResize: "common:WindowDidResize";
+        WindowDPIChanged: "common:WindowDPIChanged";
+        WindowFilesDropped: "common:WindowFilesDropped";
+        WindowFocus: "common:WindowFocus";
+        WindowFullscreen: "common:WindowFullscreen";
+        WindowHide: "common:WindowHide";
+        WindowLostFocus: "common:WindowLostFocus";
+        WindowMaximise: "common:WindowMaximise";
+        WindowMinimise: "common:WindowMinimise";
+        WindowToggleFrameless: "common:WindowToggleFrameless";
+        WindowRestore: "common:WindowRestore";
+        WindowRuntimeReady: "common:WindowRuntimeReady";
+        WindowShow: "common:WindowShow";
+        WindowUnFullscreen: "common:WindowUnFullscreen";
+        WindowUnMaximise: "common:WindowUnMaximise";
+        WindowUnMinimise: "common:WindowUnMinimise";
+        WindowZoom: "common:WindowZoom";
+        WindowZoomIn: "common:WindowZoomIn";
+        WindowZoomOut: "common:WindowZoomOut";
+        WindowZoomReset: "common:WindowZoomReset";
+        BatteryChanged: "common:BatteryChanged";
+        NetworkChanged: "common:NetworkChanged";
+        ScreenLocked: "common:ScreenLocked";
+        ScreenUnlocked: "common:ScreenUnlocked";
+        LowMemory: "common:LowMemory";
+    }>;
+}>;

package/types/events.d.ts

@@ -1,53 +1,90 @@
-export function dispatchWailsEvent(event: any): void;
+import { Types } from "./event_types.js";
+export * from "./event_types.js";
+/**
+ * A table of data types for all known events.
+ * Will be monkey-patched by the binding generator.
+ */
+export interface CustomEvents {
+}
+/**
+ * Either a known event name or an arbitrary string.
+ */
+export type WailsEventName<E extends keyof CustomEvents = keyof CustomEvents> = E | (string & {});
+/**
+ * Union of all known system event names.
+ */
+type SystemEventName = {
+    [K in keyof (typeof Types)]: (typeof Types)[K][keyof ((typeof Types)[K])];
+} extends (infer M) ? M[keyof M] : never;
+/**
+ * The data type associated to a given event.
+ */
+export type WailsEventData<E extends WailsEventName = WailsEventName> = E extends keyof CustomEvents ? CustomEvents[E] : (E extends SystemEventName ? void : any);
+/**
+ * The type of handlers for a given event.
+ */
+export type WailsEventCallback<E extends WailsEventName = WailsEventName> = (ev: WailsEvent<E>) => void;
+/**
+ * Represents a system event or a custom event emitted through wails-provided facilities.
+ */
+export declare class WailsEvent<E extends WailsEventName = WailsEventName> {
+    /**
+     * The name of the event.
+     */
+    name: E;
+    /**
+     * Optional data associated with the emitted event.
+     */
+    data: WailsEventData<E>;
+    /**
+     * Name of the originating window. Omitted for application events.
+     * Will be overridden if set manually.
+     */
+    sender?: string;
+    constructor(name: E, data: WailsEventData<E>);
+    constructor(name: WailsEventData<E> extends null | void ? E : never);
+}
 /**
  * Register a callback function to be called multiple times for a specific event.
  *
- * @param {string} eventName - The name of the event to register the callback for.
- * @param {function} callback - The callback function to be called when the event is triggered.
- * @param {number} maxCallbacks - The maximum number of times the callback can be called for the event. Once the maximum number is reached, the callback will no longer be called.
- *
- @return {function} - A function that, when called, will unregister the callback from the event.
+ * @param eventName - The name of the event to register the callback for.
+ * @param callback - The callback function to be called when the event is triggered.
+ * @param maxCallbacks - The maximum number of times the callback can be called for the event. Once the maximum number is reached, the callback will no longer be called.
+ * @returns A function that, when called, will unregister the callback from the event.
  */
-export function OnMultiple(eventName: string, callback: Function, maxCallbacks: number): Function;
+export declare function OnMultiple<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>, maxCallbacks: number): () => void;
 /**
  * Registers a callback function to be executed when the specified event occurs.
  *
- * @param {string} eventName - The name of the event.
- * @param {function} callback - The callback function to be executed. It takes no parameters.
- * @return {function} - A function that, when called, will unregister the callback from the event. */
-export function On(eventName: string, callback: Function): Function;
+ * @param eventName - The name of the event to register the callback for.
+ * @param callback - The callback function to be called when the event is triggered.
+ * @returns A function that, when called, will unregister the callback from the event.
+ */
+export declare function On<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>): () => void;
 /**
  * Registers a callback function to be executed only once for the specified event.
  *
- * @param {string} eventName - The name of the event.
- * @param {function} callback - The function to be executed when the event occurs.
- * @return {void@return {function} - A function that, when called, will unregister the callback from the event.
+ * @param eventName - The name of the event to register the callback for.
+ * @param callback - The callback function to be called when the event is triggered.
+ * @returns A function that, when called, will unregister the callback from the event.
  */
-export function Once(eventName: string, callback: Function): void;
+export declare function Once<E extends WailsEventName = WailsEventName>(eventName: E, callback: WailsEventCallback<E>): () => void;
 /**
  * Removes event listeners for the specified event names.
  *
- * @param {string} eventName - The name of the event to remove listeners for.
- * @param {...string} additionalEventNames - Additional event names to remove listeners for.
- * @return {undefined}
+ * @param eventNames - The name of the events to remove listeners for.
  */
-export function Off(eventName: string, ...additionalEventNames: string[]): undefined;
+export declare function Off(...eventNames: [WailsEventName, ...WailsEventName[]]): void;
 /**
  * Removes all event listeners.
- *
- * @function OffAll
- * @returns {void}
  */
-export function OffAll(): void;
+export declare function OffAll(): void;
 /**
- * Emits an event using the given event name.
+ * Emits an event.
  *
- * @param {WailsEvent} event - The name of the event to emit.
- * @returns {any} - The result of the emitted event.
- */
-export function Emit(event: WailsEvent): any;
-export class WailsEvent {
-    constructor(name: any, data?: any);
-    name: any;
-    data: any;
-}
+ * @returns A promise that will be fulfilled once the event has been emitted.  Resolves to true if the event was cancelled.
+ * @param name - The name of the event to emit
+ * @param data - The data that will be sent with the event
+ */
+export declare function Emit<E extends WailsEventName = WailsEventName>(name: E, data: WailsEventData<E>): Promise<boolean>;
+export declare function Emit<E extends WailsEventName = WailsEventName>(name: WailsEventData<E> extends null | void ? E : never): Promise<boolean>;

package/types/flags.d.ts

@@ -1,7 +1,7 @@
 /**
  * Retrieves the value associated with the specified key from the flag map.
  *
- * @param {string} keyString - The key to retrieve the value for.
- * @return {*} - The value associated with the specified key.
+ * @param key - The key to retrieve the value for.
+ * @return The value associated with the specified key.
  */
-export function GetFlag(keyString: string): any;
+export declare function GetFlag(key: string): any;

package/types/index.d.ts

@@ -1,48 +1,32 @@
-export namespace Events {
-    export { On };
-    export { Off };
-    export { OnMultiple };
-    export { WailsEvent };
-    export { OffAll };
-    export { Emit };
-    export { Once };
-}
-export namespace Call {
-    export { Plugin };
-    export { ByID };
-    export { ByName };
-}
-export namespace Dialogs {
-    export { Info };
-    export { Error };
-    export { OpenFile };
-    export { Question };
-    export { Warning };
-    export { SaveFile };
-}
-import * as Application from "./application";
-import * as Browser from "./browser";
-import * as Clipboard from "./clipboard";
-import * as ContextMenu from "./contextmenu";
-import * as Flags from "./flags";
-import * as Runtime from "./runtime";
-import * as Screens from "./screens";
-import * as System from "./system";
-import * as Window from "./window";
-import { On } from './events';
-import { Off } from './events';
-import { OnMultiple } from './events';
-import { WailsEvent } from './events';
-import { OffAll } from './events';
-import { Emit } from './events';
-import { Once } from './events';
-import { Plugin } from "./calls";
-import { ByID } from "./calls";
-import { ByName } from "./calls";
-import { Info } from "./dialogs";
-import { Error } from "./dialogs";
-import { OpenFile } from "./dialogs";
-import { Question } from "./dialogs";
-import { Warning } from "./dialogs";
-import { SaveFile } from "./dialogs";
-export { Application, Browser, Clipboard, ContextMenu, Flags, Runtime, Screens, System, Window };
+import "./contextmenu.js";
+import "./drag.js";
+import * as Application from "./application.js";
+import * as Browser from "./browser.js";
+import * as Call from "./calls.js";
+import * as Clipboard from "./clipboard.js";
+import * as Create from "./create.js";
+import * as Dialogs from "./dialogs.js";
+import * as Events from "./events.js";
+import * as Flags from "./flags.js";
+import * as Screens from "./screens.js";
+import * as System from "./system.js";
+import * as IOS from "./ios.js";
+import * as Android from "./android.js";
+import * as Updater from "./updater.js";
+import Window from "./window.js";
+import * as WML from "./wml.js";
+export { Application, Browser, Call, Clipboard, Dialogs, Events, Flags, Screens, System, IOS, Android, Updater, Window, WML };
+/**
+ * An internal utility consumed by the binding generator.
+ *
+ * @ignore
+ */
+export { Create };
+export * from "./cancellable.js";
+export { setTransport, getTransport, type RuntimeTransport, objectNames, clientId, } from "./runtime.js";
+/**
+ * Loads a script from the given URL if it exists.
+ * Uses HEAD request to check existence, then injects a script tag.
+ * Silently ignores if the script doesn't exist.
+ */
+export declare function loadOptionalScript(url: string): Promise<void>;

package/types/ios.d.ts

@@ -0,0 +1,13 @@
+export declare namespace Haptics {
+    type ImpactStyle = "light" | "medium" | "heavy" | "soft" | "rigid";
+    function Impact(style?: ImpactStyle): Promise<void>;
+}
+export declare namespace Device {
+    interface Info {
+        model: string;
+        systemName: string;
+        systemVersion: string;
+        isSimulator: boolean;
+    }
+    function Info(): Promise<Info>;
+}

package/types/listener.d.ts

@@ -0,0 +1,9 @@
+export declare const eventListeners: Map<string, Listener[]>;
+export declare class Listener {
+    eventName: string;
+    callback: (data: any) => void;
+    maxCallbacks: number;
+    constructor(eventName: string, callback: (data: any) => void, maxCallbacks: number);
+    dispatch(data: any): boolean;
+}
+export declare function listenerOff(listener: Listener): void;

package/types/nanoid.d.ts

@@ -0,0 +1 @@
+export declare function nanoid(size?: number): string;

package/types/plugins/vite.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from 'vite';
+/**
+ * A plugin that extends the wails runtime with locally generated code
+ * to provide support for typed custom events.
+ * With the plugin installed, vite will fail to build the project
+ * unless wails bindings have been generated first.
+ *
+ * @param {string} [bindingsRoot] - The root import path for generated bindings
+ */
+export default function WailsTypedEvents(bindingsRoot: string): Plugin;

package/types/runtime.d.ts

@@ -1,29 +1,68 @@
+import { nanoid } from "./nanoid.js";
+export { nanoid };
+export declare const objectNames: Readonly<{
+    Call: 0;
+    Clipboard: 1;
+    Application: 2;
+    Events: 3;
+    ContextMenu: 4;
+    Dialog: 5;
+    Window: 6;
+    Screens: 7;
+    System: 8;
+    Browser: 9;
+    CancelCall: 10;
+    IOS: 11;
+    Android: 12;
+}>;
+export declare let clientId: string;
 /**
- * Creates a runtime caller function that invokes a specified method on a given object within a specified window context.
+ * RuntimeTransport defines the interface for custom IPC transport implementations.
+ * Implement this interface to use WebSockets, custom protocols, or any other
+ * transport mechanism instead of the default HTTP fetch.
+ */
+export interface RuntimeTransport {
+    /**
+     * Send a runtime call and return the response.
+     *
+     * @param objectID - The Wails object ID (0=Call, 1=Clipboard, etc.)
+     * @param method - The method ID to call
+     * @param windowName - Optional window name
+     * @param args - Arguments to pass (will be JSON stringified if present)
+     * @returns Promise that resolves with the response data
+     */
+    call(objectID: number, method: number, windowName: string, args: any): Promise<any>;
+}
+/**
+ * Set a custom transport for all Wails runtime calls.
+ * This allows you to replace the default HTTP fetch transport with
+ * WebSockets, custom protocols, or any other mechanism.
+ *
+ * @param transport - Your custom transport implementation
+ *
+ * @example
+ * ```typescript
+ * import { setTransport } from '/wails/runtime.js';
  *
- * @param {Object} object - The object on which the method is to be invoked.
- * @param {string} windowName - The name of the window context in which the method should be called.
- * @returns {Function} A runtime caller function that takes the method name and optionally arguments and invokes the method within the specified window context.
+ * const wsTransport = {
+ *   call: async (objectID, method, windowName, args) => {
+ *     // Your WebSocket implementation
+ *   }
+ * };
+ *
+ * setTransport(wsTransport);
+ * ```
+ */
+export declare function setTransport(transport: RuntimeTransport | null): void;
+/**
+ * Get the current transport (useful for extending/wrapping)
  */
-export function newRuntimeCaller(object: any, windowName: string): Function;
+export declare function getTransport(): RuntimeTransport | null;
 /**
  * Creates a new runtime caller with specified ID.
  *
- * @param {object} object - The object to invoke the method on.
- * @param {string} windowName - The name of the window.
- * @return {Function} - The new runtime caller function.
+ * @param object - The object to invoke the method on.
+ * @param windowName - The name of the window.
+ * @return The new runtime caller function.
  */
-export function newRuntimeCallerWithID(object: object, windowName: string): Function;
-export namespace objectNames {
-    let Call: number;
-    let Clipboard: number;
-    let Application: number;
-    let Events: number;
-    let ContextMenu: number;
-    let Dialog: number;
-    let Window: number;
-    let Screens: number;
-    let System: number;
-    let Browser: number;
-}
-export let clientId: string;
+export declare function newRuntimeCaller(object: number, windowName?: string): (method: number, args?: any) => Promise<any>;