@owdproject/nuxt 0.0.0-stage → 4.0.0-alpha.4

package/dist/runtime/composables/useDesktopConfig.js

@@ -0,0 +1,10 @@
+import { useRuntimeConfig } from "nuxt/app";
+import { computed } from "vue";
+export function useDesktopConfig() {
+  const runtimeConfig = useRuntimeConfig();
+  return computed(() => runtimeConfig.public.desktop);
+}
+export function useDesktopExtension(key) {
+  const desktop = useDesktopConfig();
+  return computed(() => desktop.value?.[key]);
+}

package/dist/runtime/composables/useDesktopDefaultApps.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Desktop Default Apps composable (singleton pattern via Pinia).
+ * Exposes default-app routing for features like terminal, browser, editor.
+ */
+export declare function useDesktopDefaultApps(): {
+    defaultApps: import("vue").ComputedRef<Record<string, {
+        applicationId: string;
+        entry: string;
+    }>>;
+    getDefaultApp: (feature: string) => {
+        applicationId: string;
+        entry: string;
+    };
+    setDefaultApp: (feature: string, application: IApplicationController, entry: string) => void;
+};

package/dist/runtime/composables/useDesktopDefaultApps.js

@@ -0,0 +1,21 @@
+import { computed } from "vue";
+import { useDesktopStore } from "../stores/storeDesktop.js";
+import { useDesktopDefaultAppsStore } from "../stores/storeDesktopDefaultApps.js";
+export function useDesktopDefaultApps() {
+  const desktopStore = useDesktopStore();
+  const defaultAppsStore = useDesktopDefaultAppsStore();
+  const defaultApps = computed(
+    () => desktopStore.state.defaultApps
+  );
+  function getDefaultApp(feature) {
+    return defaultAppsStore.getDefaultApp(feature);
+  }
+  function setDefaultApp(feature, application, entry) {
+    defaultAppsStore.setDefaultApp(feature, application, entry);
+  }
+  return {
+    defaultApps,
+    getDefaultApp,
+    setDefaultApp
+  };
+}

package/dist/runtime/composables/useDesktopDialogs.d.ts

@@ -0,0 +1,5 @@
+import { type DesktopDialogProvider } from '../dialogs/desktopDialogProvider.js';
+/**
+ * Returns the active desktop dialog provider (theme) or a browser fallback.
+ */
+export declare function useDesktopDialogs(): DesktopDialogProvider;

package/dist/runtime/composables/useDesktopDialogs.js

@@ -0,0 +1,8 @@
+import { inject } from "vue";
+import { DESKTOP_DIALOG_PROVIDER_KEY } from "../constants/desktopShellKeys.js";
+import {
+  createBrowserFallbackDialogProvider
+} from "../dialogs/desktopDialogProvider.js";
+export function useDesktopDialogs() {
+  return inject(DESKTOP_DIALOG_PROVIDER_KEY, null) ?? createBrowserFallbackDialogProvider();
+}

package/dist/runtime/composables/useDesktopDrag.d.ts

@@ -0,0 +1 @@
+export { useDesktopDrag, type DesktopDragOptions } from '../../composables/useDesktopPointer.js';

package/dist/runtime/composables/useDesktopDrag.js

@@ -0,0 +1 @@
+export { useDesktopDrag } from "../../composables/useDesktopPointer";

package/dist/runtime/composables/useDesktopHooks.d.ts

@@ -0,0 +1,15 @@
+import type { Hookable } from 'hookable';
+import { type DesktopRuntimeHooks } from '@owdproject/core';
+import type { DesktopAppDefineContext, DesktopAppLaunchContext, DesktopAppSignalContext, DesktopWindowOpenContext, DesktopWindowCloseContext, DesktopCommandExecContext, DesktopWorkspaceSwitchContext } from '@owdproject/core';
+export type { DesktopRuntimeHooks, DesktopAppDefineContext, DesktopAppLaunchContext, DesktopAppSignalContext, DesktopWindowOpenContext, DesktopWindowCloseContext, DesktopCommandExecContext, DesktopWorkspaceSwitchContext, };
+type DesktopHookBus = Hookable<DesktopRuntimeHooks>;
+export interface DesktopHooksAPI {
+    hooks: DesktopHookBus;
+    hook: DesktopHookBus['hook'];
+    hookOnce: DesktopHookBus['hookOnce'];
+    callHook: DesktopHookBus['callHook'];
+    callHookParallel: DesktopHookBus['callHookParallel'];
+    removeHook: DesktopHookBus['removeHook'];
+    removeAllHooks: DesktopHookBus['removeAllHooks'];
+}
+export declare function useDesktopHooks(): DesktopHooksAPI;

package/dist/runtime/composables/useDesktopHooks.js

@@ -0,0 +1,12 @@
+import { globalDesktopHooks } from "@owdproject/core";
+export function useDesktopHooks() {
+  return {
+    hooks: globalDesktopHooks,
+    hook: globalDesktopHooks.hook.bind(globalDesktopHooks),
+    hookOnce: globalDesktopHooks.hookOnce.bind(globalDesktopHooks),
+    callHook: globalDesktopHooks.callHook.bind(globalDesktopHooks),
+    callHookParallel: globalDesktopHooks.callHookParallel.bind(globalDesktopHooks),
+    removeHook: globalDesktopHooks.removeHook.bind(globalDesktopHooks),
+    removeAllHooks: globalDesktopHooks.removeAllHooks.bind(globalDesktopHooks)
+  };
+}

package/dist/runtime/composables/useDesktopIPC.d.ts

@@ -0,0 +1,35 @@
+export interface DesktopKernelEvent {
+    id: string;
+    timestamp: number;
+    channel: string;
+    source: string;
+    severity: 'info' | 'warn' | 'error';
+    payload?: any;
+}
+type EventHandler = (event: DesktopKernelEvent) => void;
+export declare function useDesktopIPC(): {
+    events: import("vue").Ref<{
+        id: string;
+        timestamp: number;
+        channel: string;
+        source: string;
+        severity: "info" | "warn" | "error";
+        payload?: any;
+    }[], DesktopKernelEvent[] | {
+        id: string;
+        timestamp: number;
+        channel: string;
+        source: string;
+        severity: "info" | "warn" | "error";
+        payload?: any;
+    }[]>;
+    activeChannels: import("vue").ComputedRef<string[]>;
+    emit: (channel: string, payload?: any, options?: {
+        source?: string;
+        severity?: "info" | "warn" | "error";
+    }) => DesktopKernelEvent;
+    on: (channel: string, handler: EventHandler) => () => void;
+    off: (channel: string, handler: EventHandler) => void;
+    clearEvents: () => void;
+};
+export {};

package/dist/runtime/composables/useDesktopIPC.js

@@ -0,0 +1,72 @@
+import { ref, computed } from "vue";
+const MAX_EVENTS = 150;
+const events = ref([]);
+const listeners = /* @__PURE__ */ new Map();
+let eventCounter = 0;
+export function useDesktopIPC() {
+  function emit(channel, payload, options) {
+    eventCounter++;
+    const event = {
+      id: `evt-${Date.now()}-${eventCounter}`,
+      timestamp: Date.now(),
+      channel,
+      source: options?.source ?? "kernel",
+      severity: options?.severity ?? "info",
+      payload
+    };
+    events.value = [event, ...events.value.slice(0, MAX_EVENTS - 1)];
+    const channelSet = listeners.get(channel);
+    if (channelSet) {
+      for (const handler of channelSet) {
+        try {
+          handler(event);
+        } catch (err) {
+          console.error(`[@owdproject/nuxt][IPC] Error in listener for "${channel}":`, err);
+        }
+      }
+    }
+    if (channel !== "*") {
+      const wildcardSet = listeners.get("*");
+      if (wildcardSet) {
+        for (const handler of wildcardSet) {
+          try {
+            handler(event);
+          } catch (err) {
+            console.error(`[@owdproject/nuxt][IPC] Error in wildcard listener:`, err);
+          }
+        }
+      }
+    }
+    return event;
+  }
+  function on(channel, handler) {
+    if (!listeners.has(channel)) {
+      listeners.set(channel, /* @__PURE__ */ new Set());
+    }
+    listeners.get(channel).add(handler);
+    return () => {
+      off(channel, handler);
+    };
+  }
+  function off(channel, handler) {
+    const channelSet = listeners.get(channel);
+    if (channelSet) {
+      channelSet.delete(handler);
+      if (channelSet.size === 0) {
+        listeners.delete(channel);
+      }
+    }
+  }
+  function clearEvents() {
+    events.value = [];
+  }
+  const activeChannels = computed(() => Array.from(listeners.keys()));
+  return {
+    events,
+    activeChannels,
+    emit,
+    on,
+    off,
+    clearEvents
+  };
+}

package/dist/runtime/composables/useDesktopIdentity.d.ts

@@ -0,0 +1,22 @@
+export type ShellIdentity = {
+    userId: string;
+    displayName: string;
+    avatarUrl: string | null;
+    userHome: string;
+};
+export declare function sanitizeUserHomeSegment(input: string): string;
+/** Build a VFS home path from an auth handle (e.g. Bluesky `@alice.bsky.social`). */
+export declare function userHomeFromHandle(handle: string, base?: string): string;
+/**
+ * Shell session identity (display + VFS home). Auth modules call {@link setShellIdentity}
+ * after login; defaults to Guest.
+ */
+export declare function useDesktopIdentity(): {
+    userId: import("vue").ComputedRef<string>;
+    displayName: import("vue").ComputedRef<string>;
+    avatarUrl: import("vue").ComputedRef<string | null>;
+    userHome: import("vue").ComputedRef<string>;
+    isGuest: import("vue").ComputedRef<boolean>;
+    setDesktopIdentity: (partial: Partial<ShellIdentity>) => void;
+    clear: () => void;
+};

package/dist/runtime/composables/useDesktopIdentity.js

@@ -0,0 +1,65 @@
+import { computed, ref } from "vue";
+import { useRuntimeConfig } from "nuxt/app";
+const GUEST_USER_ID = "guest";
+const identity = ref(null);
+export function sanitizeUserHomeSegment(input) {
+  const cleaned = input.trim().replace(/^@/, "").replace(/[^\w.\-]/g, "_").slice(0, 64);
+  return cleaned || "user";
+}
+export function userHomeFromHandle(handle, base = "/home") {
+  const baseNorm = base.endsWith("/") ? base.slice(0, -1) : base;
+  return `${baseNorm}/${sanitizeUserHomeSegment(handle)}`;
+}
+function resolveDefaultHome() {
+  try {
+    const config = useRuntimeConfig();
+    const desktop = config.public.desktop;
+    const home = desktop.fs?.defaultUserHome?.trim();
+    if (home) return home.startsWith("/") ? home : `/${home}`;
+  } catch {
+  }
+  return "/home/Guest";
+}
+function guestIdentity(defaultHome) {
+  return {
+    userId: GUEST_USER_ID,
+    displayName: "Guest",
+    avatarUrl: null,
+    userHome: defaultHome
+  };
+}
+export function useDesktopIdentity() {
+  function ensureIdentity() {
+    if (!identity.value) {
+      identity.value = guestIdentity(resolveDefaultHome());
+    }
+    return identity.value;
+  }
+  const userId = computed(() => ensureIdentity().userId);
+  const displayName = computed(() => ensureIdentity().displayName);
+  const avatarUrl = computed(() => ensureIdentity().avatarUrl);
+  const userHome = computed(() => ensureIdentity().userHome);
+  const isGuest = computed(() => userId.value === GUEST_USER_ID);
+  function setDesktopIdentity(partial) {
+    const current = ensureIdentity();
+    identity.value = {
+      ...current,
+      ...partial,
+      userId: partial.userId?.trim() || current.userId,
+      displayName: partial.displayName?.trim() || current.displayName,
+      userHome: partial.userHome?.trim() ? partial.userHome.startsWith("/") ? partial.userHome : `/${partial.userHome}` : current.userHome
+    };
+  }
+  function clear() {
+    identity.value = guestIdentity(resolveDefaultHome());
+  }
+  return {
+    userId,
+    displayName,
+    avatarUrl,
+    userHome,
+    isGuest,
+    setDesktopIdentity,
+    clear
+  };
+}

package/dist/runtime/composables/useDesktopManifest.d.ts

@@ -0,0 +1,6 @@
+export declare function useHasDesktopModule(pkg: string): import("vue").ComputedRef<any>;
+export declare function useHasDesktopApp(pkg: string): import("vue").ComputedRef<any>;
+export declare function useHasDesktopExtension(key: string): import("vue").ComputedRef<boolean>;
+export declare const hasDesktopModule: typeof useHasDesktopModule;
+export declare const hasDesktopApp: typeof useHasDesktopApp;
+export declare const hasDesktopExtension: typeof useHasDesktopExtension;

package/dist/runtime/composables/useDesktopManifest.js

@@ -0,0 +1,17 @@
+import { computed } from "vue";
+import { useDesktopConfig } from "./useDesktopConfig.js";
+export function useHasDesktopModule(pkg) {
+  const desktop = useDesktopConfig();
+  return computed(() => desktop.value?.modules?.includes(pkg) ?? false);
+}
+export function useHasDesktopApp(pkg) {
+  const desktop = useDesktopConfig();
+  return computed(() => desktop.value?.apps?.includes(pkg) ?? false);
+}
+export function useHasDesktopExtension(key) {
+  const desktop = useDesktopConfig();
+  return computed(() => Boolean(desktop.value?.[key]));
+}
+export const hasDesktopModule = useHasDesktopModule;
+export const hasDesktopApp = useHasDesktopApp;
+export const hasDesktopExtension = useHasDesktopExtension;

package/dist/runtime/composables/useDesktopNotification.d.ts

@@ -0,0 +1,13 @@
+export declare function useDesktopNotification(): {
+    list: any;
+    add: (payload: {
+        title: string;
+        body?: string;
+        icon?: string;
+        appId?: string;
+    }) => DesktopNotificationItem;
+    remove: (id: string) => void;
+    clear: () => void;
+    markAsRead: (id: string) => void;
+    markAllAsRead: () => void;
+};

package/dist/runtime/composables/useDesktopNotification.js

@@ -0,0 +1,13 @@
+import { toRef } from "vue";
+import { useDesktopNotificationStore } from "../stores/storeNotification.js";
+export function useDesktopNotification() {
+  const notificationStore = useDesktopNotificationStore();
+  return {
+    list: toRef(notificationStore, "list"),
+    add: notificationStore.add,
+    remove: notificationStore.remove,
+    clear: notificationStore.clear,
+    markAsRead: notificationStore.markAsRead,
+    markAllAsRead: notificationStore.markAllAsRead
+  };
+}

package/dist/runtime/composables/useDesktopResize.d.ts

@@ -0,0 +1 @@
+export { useDesktopResize, type DesktopResizeOptions } from '../../composables/useDesktopPointer.js';

package/dist/runtime/composables/useDesktopResize.js

@@ -0,0 +1 @@
+export { useDesktopResize } from "../../composables/useDesktopPointer";

package/dist/runtime/composables/useDesktopSession.d.ts

@@ -0,0 +1,4 @@
+export declare function useDesktopSession(): {
+    shuttingDown: import("vue").Ref<boolean, boolean>;
+    initiateShutdownToStart: () => void;
+};

package/dist/runtime/composables/useDesktopSession.js

@@ -0,0 +1,17 @@
+import { useRouter } from "nuxt/app";
+import { ref } from "vue";
+const shuttingDown = ref(false);
+export function useDesktopSession() {
+  const initiateShutdownToStart = () => {
+    shuttingDown.value = true;
+    setTimeout(() => {
+      useRouter().push("/start").then(() => {
+        shuttingDown.value = false;
+      });
+    }, 2e3);
+  };
+  return {
+    shuttingDown,
+    initiateShutdownToStart
+  };
+}

package/dist/runtime/composables/useDesktopShellIdentity.d.ts

@@ -0,0 +1 @@
+export { useDesktopIdentity as useDesktopShellIdentity, type ShellIdentity, } from './useDesktopIdentity.js';

package/dist/runtime/composables/useDesktopShellIdentity.js

@@ -0,0 +1,3 @@
+export {
+  useDesktopIdentity as useDesktopShellIdentity
+} from "./useDesktopIdentity.js";

package/dist/runtime/composables/useDesktopShellOptions.d.ts

@@ -0,0 +1,5 @@
+export declare function useDesktopShellOptions(): {
+    systemBarEnabled: import("vue").ComputedRef<boolean>;
+    systemBarPosition: import("vue").ComputedRef<string | undefined>;
+    startButtonEnabled: import("vue").ComputedRef<boolean>;
+};

package/dist/runtime/composables/useDesktopShellOptions.js

@@ -0,0 +1,18 @@
+import { useAppConfig } from "nuxt/app";
+import { computed } from "vue";
+export function useDesktopShellOptions() {
+  const appConfig = useAppConfig();
+  const desktop = () => appConfig.desktop;
+  const systemBarEnabled = computed(
+    () => desktop()?.systemBar?.enabled !== false
+  );
+  const systemBarPosition = computed(() => desktop()?.systemBar?.position);
+  const startButtonEnabled = computed(
+    () => desktop()?.systemBar?.startButton !== false
+  );
+  return {
+    systemBarEnabled,
+    systemBarPosition,
+    startButtonEnabled
+  };
+}

package/dist/runtime/composables/useDesktopTray.d.ts

@@ -0,0 +1,5 @@
+export declare function useDesktopTray(): {
+    items: import("vue").ComputedRef<any>;
+    registerIcon: (item: DesktopTrayItem) => void;
+    unregisterIcon: (id: string) => void;
+};

package/dist/runtime/composables/useDesktopTray.js

@@ -0,0 +1,10 @@
+import { computed } from "vue";
+import { useDesktopTrayStore } from "../stores/storeDesktopTray.js";
+export function useDesktopTray() {
+  const trayStore = useDesktopTrayStore();
+  return {
+    items: computed(() => trayStore.items),
+    registerIcon: trayStore.registerIcon,
+    unregisterIcon: trayStore.unregisterIcon
+  };
+}

package/dist/runtime/composables/useDesktopVolume.d.ts

@@ -0,0 +1,4 @@
+export declare function useDesktopVolume(): {
+    master: import("vue").ComputedRef<number>;
+    setMaster: (value: number) => void;
+};

package/dist/runtime/composables/useDesktopVolume.js

@@ -0,0 +1,9 @@
+import { computed } from "vue";
+import { useDesktopVolumeStore } from "../stores/storeDesktopVolume.js";
+export function useDesktopVolume() {
+  const volumeStore = useDesktopVolumeStore();
+  return {
+    master: computed(() => volumeStore.master),
+    setMaster: volumeStore.setMasterVolume
+  };
+}

package/dist/runtime/composables/useDesktopWorkArea.d.ts

@@ -0,0 +1 @@
+export { useDesktopWorkarea as useDesktopWorkArea, } from './useDesktopWorkarea.js';

package/dist/runtime/composables/useDesktopWorkArea.js

@@ -0,0 +1,3 @@
+export {
+  useDesktopWorkarea as useDesktopWorkArea
+} from "./useDesktopWorkarea.js";

package/dist/runtime/composables/useDesktopWorkarea.d.ts

@@ -0,0 +1,12 @@
+import type { Ref } from 'vue';
+/**
+ * Tracks the desktop shell stage rectangle (area under system bar, above dock).
+ * When called with no arguments, returns the read-only workarea ref.
+ * When passed a shellStageRef, also registers the resize observer to update the workarea.
+ */
+export declare function useDesktopWorkarea(shellStageRef?: Ref<HTMLElement | null | undefined>): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};

package/dist/runtime/composables/useDesktopWorkarea.js

@@ -0,0 +1,72 @@
+import { onScopeDispose, watch } from "vue";
+import {
+  EMPTY_DESKTOP_WORKAREA,
+  useDesktopWorkspaceStore
+} from "../stores/storeDesktopWorkspace.js";
+function measureElement(el) {
+  const rect = el.getBoundingClientRect();
+  return {
+    x: rect.left,
+    y: rect.top,
+    width: rect.width,
+    height: rect.height
+  };
+}
+export function useDesktopWorkarea(shellStageRef) {
+  const desktopWorkspaceStore = useDesktopWorkspaceStore();
+  if (!shellStageRef) {
+    return desktopWorkspaceStore.workarea;
+  }
+  let resizeObserver = null;
+  function refreshWorkarea() {
+    const el = shellStageRef.value;
+    if (!el) {
+      desktopWorkspaceStore.setWorkarea({ ...EMPTY_DESKTOP_WORKAREA });
+      return;
+    }
+    desktopWorkspaceStore.setWorkarea(measureElement(el));
+  }
+  function disconnectObserver() {
+    resizeObserver?.disconnect();
+    resizeObserver = null;
+  }
+  function observeStage(el) {
+    disconnectObserver();
+    refreshWorkarea();
+    if (typeof ResizeObserver === "undefined") {
+      return;
+    }
+    resizeObserver = new ResizeObserver(() => refreshWorkarea());
+    resizeObserver.observe(el);
+  }
+  watch(
+    shellStageRef,
+    (el) => {
+      disconnectObserver();
+      if (typeof HTMLElement !== "undefined" && el instanceof HTMLElement) {
+        observeStage(el);
+      } else {
+        desktopWorkspaceStore.setWorkarea({ ...EMPTY_DESKTOP_WORKAREA });
+      }
+    },
+    { immediate: true }
+  );
+  watch(
+    () => desktopWorkspaceStore.overview,
+    (open) => {
+      if (!open) {
+        refreshWorkarea();
+      }
+    }
+  );
+  if (typeof window !== "undefined") {
+    window.addEventListener("resize", refreshWorkarea);
+    onScopeDispose(() => {
+      window.removeEventListener("resize", refreshWorkarea);
+      disconnectObserver();
+    });
+  } else {
+    onScopeDispose(disconnectObserver);
+  }
+  return desktopWorkspaceStore.workarea;
+}

package/dist/runtime/composables/useTerminalManager.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @deprecated Use useDesktopCommands instead
+ */
+export declare function useTerminalManager(): {
+    register: (command: DesktopCommand) => void;
+    list: () => string[];
+    get: (name: string) => DesktopCommand | undefined;
+    all: () => DesktopCommand[];
+    exec: (input: string) => Promise<CommandOutput | void>;
+    addCommand: (command: DesktopCommand) => void;
+    listCommands: () => string[];
+    getCommand: (name: string) => DesktopCommand | undefined;
+    getAllCommands: () => DesktopCommand[];
+    execCommand: (input: string) => Promise<CommandOutput | void>;
+};

package/dist/runtime/composables/useTerminalManager.js

@@ -0,0 +1,9 @@
+import { useDesktopCommands } from "./useDesktopCommands.js";
+export function useTerminalManager() {
+  if (process.dev) {
+    console.warn(
+      "[@owdproject/nuxt] useTerminalManager() is deprecated. Please use useDesktopCommands() or useDesktop().commands instead."
+    );
+  }
+  return useDesktopCommands();
+}

package/dist/runtime/composables/useToggleWindowMaximize.d.ts

@@ -0,0 +1 @@
+export declare function useToggleWindowMaximize(): (win: any) => any;

package/dist/runtime/composables/useToggleWindowMaximize.js

@@ -0,0 +1,12 @@
+export function useToggleWindowMaximize() {
+  return function toggle(win) {
+    if (!win) return false;
+    if (typeof win.toggleMaximize === "function") {
+      return win.toggleMaximize();
+    }
+    if (typeof win.actions?.toggleMaximize === "function") {
+      return win.actions.toggleMaximize();
+    }
+    return false;
+  };
+}

package/dist/runtime/composables/useWindowDragHandlers.d.ts

@@ -0,0 +1,7 @@
+export declare function useWindowDragHandlers(_getWindow?: () => any): {
+    onDragStart: () => void;
+    onDragEnd: (_data?: {
+        left: number;
+        top: number;
+    }) => void;
+};

package/dist/runtime/composables/useWindowDragHandlers.js

@@ -0,0 +1,7 @@
+export function useWindowDragHandlers(_getWindow) {
+  function onDragStart() {
+  }
+  function onDragEnd(_data) {
+  }
+  return { onDragStart, onDragEnd };
+}

package/dist/runtime/composables/window/useDesktopWindow.d.ts

@@ -0,0 +1,14 @@
+export declare function useDesktopWindow(): {
+    list: import("vue").ComputedRef<IWindowController[]>;
+    index: import("vue").ComputedRef<Map<string, IWindowController>>;
+    activeWorkspaceWindows: import("vue").ComputedRef<IWindowController[]>;
+    focused: import("vue").ComputedRef<any>;
+    topMaximizedWindow: import("vue").ComputedRef<any>;
+    get: (windowId: string) => IWindowController | undefined;
+    tileWindows: (mode?: "horizontal" | "vertical" | "grid", workspaceId?: string) => number;
+    minimizeAll: (workspaceId?: string) => void;
+    restoreAll: (workspaceId?: string) => void;
+    close: (windowId: string) => void;
+    closeAll: (appId?: string) => void;
+};
+export declare const useDesktopWindows: typeof useDesktopWindow;