@wailsio/runtime 3.0.0-alpha.6 → 3.0.0-alpha.8

package/package.json

@@ -1,17 +1,26 @@
 {
   "name": "@wailsio/runtime",
-  "version": "3.0.0-alpha.6",
+  "version": "3.0.0-alpha.8",
   "description": "Wails Runtime",
-  "main": "index.js",
+  "main": "src/index.js",
+  "types": "types/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/wailsapp/wails.git"
   },
+  "scripts": {
+    "prebuild:types": "rimraf ./types",
+    "build:types": "npx -p typescript tsc src/index.js --declaration --allowJs --emitDeclarationOnly --outDir types"
+  },
   "author": "The Wails Team",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/wailsapp/wails/issues"
   },
   "homepage": "https://wails.io",
-  "private": false
+  "private": false,
+  "devDependencies": {
+    "rimraf": "^5.0.5",
+    "typescript": "^5.3.3"
+  }
 }

package/{application.js → src/application.js}

@@ -11,7 +11,7 @@ The electron alternative for Go
 /* jshint esversion: 9 */
 
 import { newRuntimeCallerWithID, objectNames } from "./runtime";
-const call = newRuntimeCallerWithID(objectNames.Application);
+const call = newRuntimeCallerWithID(objectNames.Application, '');
 
 const HideMethod = 0;
 const ShowMethod = 1;

package/src/index.d.ts

@@ -0,0 +1,136 @@
+declare module '@wailsio/runtime';
+
+/**
+ * Describes the properties of a Button object.
+ */
+export interface Button {
+    // Text that appears within the button.
+    Label?: string;
+    // True if the button should cancel an operation when clicked.
+    IsCancel?: boolean;
+    // True if the button should be the default action when the user presses enter.
+    IsDefault?: boolean;
+}
+
+/**
+ * Describes the properties of a FileFilter object.
+ */
+export interface FileFilter {
+    // Display name for the filter, it could be "Text Files", "Images" etc.
+    DisplayName?: string;
+    // Pattern to match for the filter, e.g. "*.txt;*.md" for text markdown files.
+    Pattern?: string;
+}
+
+/**
+ * Describes the properties of a Position object.
+ */
+export interface Position {
+    X: number;
+    Y: number;
+}
+
+/**
+ * Describes the properties of a Size object.
+ * Extends the properties of Position.
+ */
+export type Size = Position;
+
+/**
+ * Describes the properties of a Rect object.
+ * Extends the properties of Size.
+ */
+export type Rect = Size & Position;
+
+/**
+ * Describes the possible rotations a Screen can have.
+ */
+export enum Rotation {
+    Zero = 0,
+    Ninety = 90,
+    OneEighty = 180,
+    TwoSeventy = 270
+}
+
+/**
+ * Describes the properties of a Screen object.
+ */
+export interface Screen {
+    // Unique identifier for the screen.
+    Id: string;
+    // Human readable name of the screen.
+    Name: string;
+    // The resolution scale of the screen. 1 = standard resolution, 2 = high (Retina), etc.
+    Scale: number;
+    // Contains the X and Y coordinates of the screen's position.
+    Position: Position;
+    // Contains the width and height of the screen.
+    Size: Size;
+    // Contains the bounds of the screen in terms of X, Y, Width, and Height.
+    Bounds: Rect;
+    // Contains the area of the screen that is actually usable (excluding taskbar and other system UI).
+    WorkArea: Rect;
+    // True if this is the primary monitor selected by the user in the operating system.
+    IsPrimary: boolean;
+    // The rotation of the screen. Can be one of 0, 90, 180, 270 degrees.
+    Rotation: Rotation;
+}
+
+/**
+ * Describes the properties of a MessageDialogOptions object.
+ */
+export interface MessageDialogOptions {
+    // The title of the dialog window.
+    Title?: string;
+    // The main message to show in the dialog.
+    Message?: string;
+    // Array of button options to show in the dialog.
+    Buttons?: Button[];
+    // True if the dialog should appear detached from the main window (if applicable).
+    Detached?: boolean;
+}
+
+/**
+ * Describes the properties common to OpenFileDialogOptions and SaveFileDialogOptions objects.
+ */
+export interface DialogOptions {
+    CanChooseDirectories?: boolean;
+    CanChooseFiles?: boolean;
+    CanCreateDirectories?: boolean;
+    ShowHiddenFiles?: boolean;
+    ResolvesAliases?: boolean;
+    AllowsMultipleSelection?: boolean;
+    HideExtension?: boolean;
+    CanSelectHiddenExtension?: boolean;
+    TreatsFilePackagesAsDirectories?: boolean;
+    AllowsOtherFiletypes?: boolean;
+    Filters?: FileFilter[];
+    Title?: string;
+    Message?: string;
+    ButtonText?: string;
+    Directory?: string;
+    Detached?: boolean;
+}
+
+/**
+ * Describes properties unique to OpenFileDialogOptions.
+ */
+export type OpenFileDialogOptions = DialogOptions;
+
+/**
+ * Describes properties unique to SaveFileDialogOptions.
+ */
+export type SaveFileDialogOptions = DialogOptions & {
+    // Default filename to use for the save dialog.
+    Filename?: string;
+};
+
+/**
+ * Describes the properties of a WailsEvent object.
+ */
+export interface WailsEvent {
+    // The name of the event.
+    Name: string;
+    // Any data associated with the event.
+    Data?: unknown;
+}

package/{index.js → src/index.js}

@@ -15,15 +15,17 @@ import {Emit, Off, OffAll, On, Once, OnMultiple, WailsEvent} from './events';
 import {ByID, ByName, Plugin} from "./calls";
 import {Error, Info, OpenFile, Question, SaveFile, Warning} from "./dialogs";
 
-export * as Application from "./application";
-export * as Browser from "./browser";
-export * as Clipboard from "./clipboard";
-export * as ContextMenu from "./contextmenu";
-export * as Flags from "./flags";
-export * as Runtime from "./runtime";
-export * as Screens from "./screens";
-export * as System from "./system";
-export * as Window from "./window";
+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";
+
+export { Application, Browser, Clipboard, ContextMenu, Flags, Runtime, Screens, System, Window };
 
 export const Events = {
     On,

package/{wml.js → src/wml.js}

@@ -49,22 +49,23 @@ function addWMLEventListeners() {
     });
 }
 
+
 /**
- * Calls a method on the window object.
- *
- * @param {string} method - The name of the method to call on the window object.
- *
- * @return {void}
+ * Calls a method on a specified window.
+ * @param {string} windowName - The name of the window to call the method on.
+ * @param {string} method - The name of the method to call.
  */
-function callWindowMethod(method) {
-    // TODO: Make this a parameter!
-    let windowName = '';
-    let targetWindow = Get('');
+function callWindowMethod(windowName, method) {
+    let targetWindow = Get(windowName);
     let methodMap = WindowMethods(targetWindow);
     if (!methodMap.has(method)) {
         console.log("Window method " + method + " not found");
     }
-    methodMap.get(method)();
+    try {
+        methodMap.get(method)();
+    } catch (e) {
+        console.error("Error calling window method '" + method + "': " + e);
+    }
 }
 
 /**
@@ -78,18 +79,19 @@ function addWMLWindowListeners() {
     elements.forEach(function (element) {
         const windowMethod = element.getAttribute('wml-window');
         const confirm = element.getAttribute('wml-confirm');
-        const trigger = element.getAttribute('wml-trigger') || "click";
+        const trigger = element.getAttribute('wml-trigger') || 'click';
+        const targetWindow = element.getAttribute('wml-target-window') || '';
 
         let callback = function () {
             if (confirm) {
                 Question({Title: "Confirm", Message:confirm, Buttons:[{Label:"Yes"},{Label:"No", IsDefault:true}]}).then(function (result) {
                     if (result !== "No") {
-                        callWindowMethod(windowMethod);
+                        callWindowMethod(targetWindow, windowMethod);
                     }
                 });
                 return;
             }
-            callWindowMethod(windowMethod);
+            callWindowMethod(targetWindow, windowMethod);
         };
 
         // Remove existing listeners

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "include": ["./src/**/*"],
+  "compilerOptions": {
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "outDir": "dist",
+    "strict": true,
+    "target": "es6"
+  }
+}

package/types/application.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hides a certain method by calling the HideMethod function.
+ *
+ * @return {Promise<void>}
+ *
+ */
+export function Hide(): Promise<void>;
+/**
+ * Calls the ShowMethod and returns the result.
+ *
+ * @return {Promise<void>}
+ */
+export function Show(): Promise<void>;
+/**
+ * Calls the QuitMethod to terminate the program.
+ *
+ * @return {Promise<void>}
+ */
+export function Quit(): Promise<void>;

package/types/browser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Open a browser window to the given URL
+ * @param {string} url - The URL to open
+ * @returns {Promise<string>}
+ */
+export function OpenURL(url: string): Promise<string>;

package/types/calls.d.ts

@@ -0,0 +1,35 @@
+export function resultHandler(id: any, data: any, isJSON: any): void;
+export function errorHandler(id: any, message: any): void;
+/**
+ * Call method.
+ *
+ * @param {Object} options - The options for the method.
+ * @returns {Object} - The result of the call.
+ */
+export function Call(options: any): any;
+/**
+ * Executes a method by name.
+ *
+ * @param {string} name - The name of the method in the format 'package.struct.method'.
+ * @param {...*} args - The arguments to pass to the method.
+ * @throws {Error} If the name is not a string or is not in the correct format.
+ * @returns {*} The result of the method execution.
+ */
+export function ByName(name: string, ...args: any[]): any;
+/**
+ * Calls a method by its ID with the specified arguments.
+ *
+ * @param {string} methodID - The ID of the method to call.
+ * @param {...*} args - The arguments to pass to the method.
+ * @return {*} - The result of the method call.
+ */
+export function ByID(methodID: string, ...args: any[]): any;
+/**
+ * Calls a method on a plugin.
+ *
+ * @param {string} pluginName - The name of the plugin.
+ * @param {string} methodName - The name of the method to call.
+ * @param {...*} args - The arguments to pass to the method.
+ * @returns {*} - The result of the method call.
+ */
+export function Plugin(pluginName: string, methodName: string, ...args: any[]): any;

package/types/clipboard.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Sets the text to the Clipboard.
+ *
+ * @param {string} text - The text to be set to the Clipboard.
+ * @return {Promise} - A Promise that resolves when the operation is successful.
+ */
+export function SetText(text: string): Promise<any>;
+/**
+ * Get the Clipboard text
+ * @returns {Promise<string>} A promise that resolves with the text from the Clipboard.
+ */
+export function Text(): Promise<string>;

package/types/contextmenu.d.ts

@@ -0,0 +1 @@
+export function setupContextMenus(): void;

package/types/dialogs.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Handles the callback from a dialog.
+ *
+ * @param {string} id - The ID of the dialog response.
+ * @param {string} data - The data received from the dialog.
+ * @param {boolean} isJSON - Flag indicating whether the data is in JSON format.
+ *
+ * @return {undefined}
+ */
+export function dialogCallback(id: string, data: string, isJSON: boolean): undefined;
+/**
+ * Callback function for handling errors in dialog.
+ *
+ * @param {string} id - The id of the dialog response.
+ * @param {string} message - The error message.
+ *
+ * @return {void}
+ */
+export function dialogErrorCallback(id: string, message: string): void;
+export function Info(options: any): Promise<string>;
+export function Warning(options: any): Promise<string>;
+export function Error(options: any): Promise<string>;
+export function Question(options: any): Promise<string>;
+export function OpenFile(options: any): Promise<string[] | string>;
+export function SaveFile(options: any): Promise<string>;
+export type MessageDialogOptions = any;
+export type OpenDialogOptions = any;
+export type SaveDialogOptions = any;

package/types/drag.d.ts

@@ -0,0 +1,4 @@
+export function dragTest(e: any): boolean;
+export function setupDrag(): void;
+export function setResizable(value: any): void;
+export function endDrag(): void;

package/types/events.d.ts

@@ -0,0 +1,53 @@
+export function dispatchWailsEvent(event: any): void;
+/**
+ * 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.
+ */
+export function OnMultiple(eventName: string, callback: Function, maxCallbacks: number): Function;
+/**
+ * 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;
+/**
+ * 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.
+ */
+export function Once(eventName: string, callback: Function): 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}
+ */
+export function Off(eventName: string, ...additionalEventNames: string[]): undefined;
+/**
+ * Removes all event listeners.
+ *
+ * @function OffAll
+ * @returns {void}
+ */
+export function OffAll(): void;
+/**
+ * Emits an event using the given event name.
+ *
+ * @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;
+}

package/types/flags.d.ts

@@ -0,0 +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.
+ */
+export function GetFlag(keyString: string): any;

package/types/index.d.ts

@@ -0,0 +1,48 @@
+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 };

package/types/runtime.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Creates a runtime caller function that invokes a specified method on a given object within a specified window context.
+ *
+ * @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.
+ */
+export function newRuntimeCaller(object: any, windowName: string): Function;
+/**
+ * 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.
+ */
+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;

package/types/screens.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Gets all screens.
+ * @returns {Promise<Screen[]>} A promise that resolves to an array of Screen objects.
+ */
+export function GetAll(): Promise<Screen[]>;
+/**
+ * Gets the primary screen.
+ * @returns {Promise<Screen>} A promise that resolves to the primary screen.
+ */
+export function GetPrimary(): Promise<Screen>;
+/**
+ * Gets the current active screen.
+ *
+ * @returns {Promise<Screen>} A promise that resolves with the current active screen.
+ */
+export function GetCurrent(): Promise<Screen>;
+export type Screen = any;

package/types/system.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @function
+ * Retrieves the system dark mode status.
+ * @returns {Promise<boolean>} - A promise that resolves to a boolean value indicating if the system is in dark mode.
+ */
+export function IsDarkMode(): Promise<boolean>;
+/**
+ * Fetches the capabilities of the application from the server.
+ *
+ * @async
+ * @function Capabilities
+ * @returns {Promise<Object>} A promise that resolves to an object containing the capabilities.
+ */
+export function Capabilities(): Promise<any>;
+/**
+ * @typedef {object} EnvironmentInfo
+ * @property {string} OS - The operating system in use.
+ * @property {string} Arch - The architecture of the system.
+ */
+/**
+ * @function
+ * Retrieves environment details.
+ * @returns {Promise<EnvironmentInfo>} - A promise that resolves to an object containing OS and system architecture.
+ */
+export function Environment(): Promise<EnvironmentInfo>;
+/**
+ * Checks if the current operating system is Windows.
+ *
+ * @return {boolean} True if the operating system is Windows, otherwise false.
+ */
+export function IsWindows(): boolean;
+/**
+ * Checks if the current operating system is Linux.
+ *
+ * @returns {boolean} Returns true if the current operating system is Linux, false otherwise.
+ */
+export function IsLinux(): boolean;
+/**
+ * Checks if the current environment is a macOS operating system.
+ *
+ * @returns {boolean} True if the environment is macOS, false otherwise.
+ */
+export function IsMac(): boolean;
+/**
+ * Checks if the current environment architecture is AMD64.
+ * @returns {boolean} True if the current environment architecture is AMD64, false otherwise.
+ */
+export function IsAMD64(): boolean;
+/**
+ * Checks if the current architecture is ARM.
+ *
+ * @returns {boolean} True if the current architecture is ARM, false otherwise.
+ */
+export function IsARM(): boolean;
+/**
+ * Checks if the current environment is ARM64 architecture.
+ *
+ * @returns {boolean} - Returns true if the environment is ARM64 architecture, otherwise returns false.
+ */
+export function IsARM64(): boolean;
+export function IsDebug(): boolean;
+export let invoke: any;
+export type EnvironmentInfo = {
+    /**
+     * - The operating system in use.
+     */
+    OS: string;
+    /**
+     * - The architecture of the system.
+     */
+    Arch: string;
+};

package/types/window.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Gets the specified window.
+ *
+ * @param {string} windowName - The name of the window to get.
+ * @return {Object} - The specified window object.
+ */
+export function Get(windowName: string): any;
+/**
+ * Returns a map of all methods in the current window.
+ * @returns {Map} - A map of window methods.
+ */
+export function WindowMethods(targetWindow: any): Map<any, any>;
+declare const _default: any;
+export default _default;
+export type Size = any;
+export type Position = any;
+export type Screen = any;

package/types/wml.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reloads the WML page by adding necessary event listeners and browser listeners.
+ *
+ * @return {void}
+ */
+export function reloadWML(): void;

package/types.d.ts

@@ -1,130 +0,0 @@
-
-export interface Button {
-    // The label of the button
-    Label?: string;
-    // True if this button is the cancel button (selected when pressing escape)
-    IsCancel?: boolean;
-    // True if this button is the default button (selected when pressing enter)
-    IsDefault?: boolean;
-}
-
-interface MessageDialogOptions {
-    // The title for the dialog
-    Title?: string;
-    // The message to display
-    Message?: string;
-    // The buttons to use on the dialog
-    Buttons?: Button[];
-    // Whether the dialog is detached from the current window
-    Detached?: boolean;
-}
-
-export interface OpenFileDialogOptions {
-    // Allows the user to be able to select directories
-    CanChooseDirectories?: boolean;
-    // Allows the user to be able to select files
-    CanChooseFiles?: boolean;
-    // Provide an option to create directories in the dialog
-    CanCreateDirectories?: boolean;
-    // Makes the dialog show hidden files
-    ShowHiddenFiles?: boolean;
-    // Whether the dialog should follow filesystem aliases
-    ResolvesAliases?: boolean;
-    // Allow the user to select multiple files or directories
-    AllowsMultipleSelection?: boolean;
-    // Hide the extension when showing the filename
-    HideExtension?: boolean;
-    // Allow the user to select files where the system hides their extensions
-    CanSelectHiddenExtension?: boolean;
-    // Treats file packages as directories, e.g. .app on macOS
-    TreatsFilePackagesAsDirectories?: boolean;
-    // Allows selection of filetypes not specified in the filters
-    AllowsOtherFiletypes?: boolean;
-    // The file filters to use in the dialog
-    Filters?: FileFilter[];
-    // The title of the dialog
-    Title?: string;
-    // The message to display
-    Message?: string;
-    // The label for the select button
-    ButtonText?: string;
-    // The default directory to open the dialog in
-    Directory?: string;
-    // Whether the dialog is detached from the current window
-    Detached?: boolean;
-}
-export interface FileFilter {
-    // The display name for the filter, e.g. "Text Files"
-    DisplayName?: string;
-    // The pattern to use for the filter, e.g. "*.txt;*.md"
-    Pattern?: string;
-}
-export interface SaveFileDialogOptions {
-    // Provide an option to create directories in the dialog
-    CanCreateDirectories?: boolean;
-    // Makes the dialog show hidden files
-    ShowHiddenFiles?: boolean;
-    // Allow the user to select files where the system hides their extensions
-    CanSelectHiddenExtension?: boolean;
-    // Allows selection of filetypes not specified in the filters
-    AllowOtherFiletypes?: boolean;
-    // Hide the extension when showing the filename
-    HideExtension?: boolean;
-    // Treats file packages as directories, e.g. .app on macOS
-    TreatsFilePackagesAsDirectories?: boolean;
-    // The message to show in the dialog
-    Message?: string;
-    // The default directory to open the dialog in
-    Directory?: string;
-    // The default filename to use in the dialog
-    Filename?: string;
-    // The label for the select button
-    ButtonText?: string;
-    // Whether the dialog is detached from the current window
-    Detached?: boolean;
-}
-
-export interface Screen {
-    // The screen ID
-    Id: string;
-    // The screen name
-    Name: string;
-    // The screen scale. 1 = standard resolution, 2: 2x retina, etc.
-    Scale: number;
-    // The X position of the screen
-    X: number;
-    // The Y position of the screen
-    Y: number;
-    // The width and height of the screen
-    Size: Size;
-    // The bounds of the screen
-    Bounds: Rect;
-    // The work area of the screen
-    WorkArea: Rect;
-    // True if this is the primary screen
-    IsPrimary: boolean;
-    // The rotation of the screen
-    Rotation: number;
-}
-export interface Rect {
-    X: number;
-    Y: number;
-    Width: number;
-    Height: number;
-}
-
-export interface WailsEvent {
-    // The name of the event
-    Name: string;
-    // The data associated with the event
-    Data?: any;
-}
-
-export interface Size {
-    Width: number;
-    Height: number;
-}
-export interface Position {
-    X: number;
-    Y: number;
-}