@prozilla-os/core 1.3.13 → 2.0.1

package/dist/main.d.ts

@@ -1,36 +1,44 @@
 import { Context } from 'react';
+import { EventEmitter } from '@prozilla-os/shared';
 import { FC } from 'react';
+import { ForwardRefExoticComponent } from 'react';
 import { HTMLAttributeAnchorTarget } from 'react';
-import { IconProp } from '@fortawesome/fontawesome-svg-core';
+import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
 import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { Listener } from '@prozilla-os/shared';
 import { MemoExoticComponent } from 'react';
 import { MouseEvent as MouseEvent_2 } from 'react';
 import { MutableRefObject } from 'react';
 import { NamedExoticComponent } from 'react';
 import { ReactElement } from 'react';
 import { ReactNode } from 'react';
-import { Ref } from 'react';
+import { RefAttributes } from 'react';
+import { RefObject } from 'react';
+import { Skin } from '@prozilla-os/skins';
+import { Snapshot } from 'valtio';
 import { UaEventOptions } from 'react-ga4/types/ga4';
+import { UIEvent as UIEvent_2 } from 'react';
 import { default as utilStyles } from './utils.module.css';
+import { Vector2 } from '@prozilla-os/shared';
 
 export declare interface ActionProps {
-    /** ID of the action */
+    /** ID of the action. */
     actionId?: string;
-    /** Label of the action */
+    /** Label of the action. */
     label?: string;
-    /** Icon for the action */
+    /** Icon for the action. */
     icon?: string | object;
-    /** Keyboard shortcut for the action */
+    /** Keyboard shortcut for the action. */
     shortcut?: string[];
-    /** Function that handles the trigger event for the action */
+    /** Function that handles the trigger event for the action. */
     onTrigger?: (event?: Event, triggerParams?: unknown, ...args: unknown[]) => void;
     children?: ReactNode;
-    /** Whether the action should be disabled */
+    /** Whether the action should be disabled. */
     disabled?: boolean;
 }
 
 /**
- * Component that renders a collection of actions (e.g., as a context menu or a header menu) and handles keyboard shortcuts
+ * Component that renders a collection of actions (e.g., as a context menu or a header menu) and handles keyboard shortcuts.
  * @example
  * <ClickAction
  * 	label="Reload"
@@ -45,93 +53,99 @@ export declare function Actions({ children, mode, className, onAnyTrigger, trigg
 
 export declare interface ActionsProps {
     mode?: string;
-    /** `className` prop for the container */
+    /** `className` prop for the container. */
     className?: string;
-    /** Function that handles the trigger event for all actions */
+    /** Function that handles the trigger event for all actions. */
     onAnyTrigger?: (event: Event, triggerParams: unknown, ...args: unknown[]) => void;
     children?: ReactNode;
-    /** The parameters to pass whenever an action is triggered */
+    /** The parameters to pass whenever an action is triggered. */
     triggerParams?: unknown;
-    /** Whether the actions should automatically orient themselves to not overlap with the taskbar */
+    /** Whether the actions should automatically orient themselves to not overlap with the taskbar. */
     avoidTaskbar?: boolean;
     [key: string]: unknown;
 }
 
 export declare interface AlertParams {
     /**
-     * The title of the alert
+     * The title of the alert.
      * @default "Alert"
      */
-    title: string;
-    /** The body of the alert */
+    title?: string;
+    /** The body of the alert. */
     text: string;
-    /** The URL of the icon of the alert */
+    /** The URL of the icon of the alert. */
     iconUrl?: string;
     /**
-     * The size of the alert modal
+     * The size of the alert modal.
      * @default new Vector2(300, 150)
      */
     size?: Vector2;
     single?: boolean;
 }
 
+export declare const ANSI_ASCII_LOGO: string;
+
+export declare const ANSI_LOGO_COLOR: string;
+
 /**
- * An application that can be ran by ProzillaOS
- * Applications can be installed by adding them to the `apps` array in {@link AppsConfig}
+ * An application that can be ran by ProzillaOS.
+ *
+ * Applications can be installed by adding them to {@link AppsConfig.apps}.
+ * @typeParam AppProps - The props of the {@link windowContent} of this app.
  */
 export declare class App<AppProps extends WindowProps = WindowProps> {
     /**
-     * The display name of this application
+     * The display name of this application.
      */
     name: string;
     /**
-     * The unique ID of this application
+     * The unique ID of this application.
      */
     id: string;
     /**
-     * Main component that renders this app inside a window
+     * Main component that renders this app inside a window.
      */
-    windowContent: FC<AppProps>;
+    windowContent: FC<AppProps> | null;
     /**
-     * Default options that get passed to the {@link App.windowContent} component
+     * Default options that get passed to the {@link App.windowContent} component.
      */
     windowOptions?: Partial<AppProps> & DefaultWindowOptions;
     /**
-     * Description of this application
+     * Description of this application.
      */
     description: string | null;
     /**
-     * URL of the icon of this application
+     * URL of the icon of this application.
      */
     iconUrl: string | null;
     /**
-     * Defines what the app can handle and how it can be used elsewhere in the system
+     * Defines what the app can handle and how it can be used elsewhere in the system.
      */
     role: string | null;
     /**
-     * An array of file extensions that this application can interpret
+     * An array of file extensions that this application can interpret.
      */
     associatedExtensions: string[];
     /**
-     * Determines whether the app is pinned by default
+     * Determines whether the app is pinned by default.
      * @default true
      */
     pinnedByDefault: boolean;
     /**
-     * Determines whether the app is launched at startup
+     * Determines whether the app is launched at startup.
      * @default false
      */
     launchAtStartup: boolean;
     /**
-     * The category the app belongs to
+     * The category the app belongs to.
      */
     category: typeof APP_CATEGORIES[number] | null;
     /**
-     * Metadata of the app's package
+     * Metadata of the app's package.
      */
     metadata: AppMetadata | null;
     /**
-     * Determines whether a desktop icon is added to the default data
+     * Determines whether a desktop icon is added to the default data.
      * @default false
      */
     showDesktopIcon: boolean;
@@ -140,55 +154,55 @@ export declare class App<AppProps extends WindowProps = WindowProps> {
     isInstalled: boolean;
     constructor(name: App["name"], id: App["id"], windowContent: App<AppProps>["windowContent"], windowOptions?: Partial<AppProps> & DefaultWindowOptions);
     /**
-     * Returns the component that renders the content of a window for this app
+     * Returns the component that renders the content of a window for this app.
      */
     WindowContent: (props: AppProps) => JSX_2.Element | null;
     /**
-     * Sets the display name of this application
+     * Sets the display name of this application.
      */
     setName(name: string): this;
     /**
-     * Sets the description of this application
+     * Sets the description of this application.
      */
     setDescription(description: App["description"]): this;
     /**
-     * Sets the URL of the icon of this application
+     * Sets the URL of the icon of this application.
      */
     setIconUrl(iconUrl: App["iconUrl"]): this;
     /**
-     * Sets the role of this application
+     * Sets the role of this application.
      */
     setRole(role: string | null): this;
     /**
-     * Sets the associated extensions of this application
+     * Sets the associated extensions of this application.
      */
     setAssociatedExtensions(extensions: string[] | null): this;
     /**
-     * Changes whether this application is pinned by default or not
+     * Changes whether this application is pinned by default or not.
      */
     setPinnedByDefault(pinnedByDefault: boolean): this;
     /**
-     * Changes whether this application is launched at startup or not
+     * Changes whether this application is launched at startup or not.
      */
     setLaunchAtStartup(launchAtStartup: boolean): this;
     /**
-     * Changes whether this application is installed by default or not
+     * Changes whether this application is installed by default or not.
      */
     setInstalled(installed: boolean): this;
     /**
-     * Sets the category this application belongs to
+     * Sets the category this application belongs to.
      */
     setCategory(category: typeof APP_CATEGORIES[number] | null): this;
     /**
-     * Sets the metadata for this application
+     * Sets the metadata for this application.
      */
     setMetadata(metadata: AppMetadata | null): this;
     /**
-     * Changes whether this application has a desktop icon in the default data
+     * Changes whether this application has a desktop icon in the default data.
      */
     setShowDesktopIcon(showDesktopIcon: boolean): this;
     /**
-     * Sets the default options for the {@link App.windowContent} component
+     * Sets the default options for the {@link App.windowContent} component.
      */
     setWindowOptions(windowOptions: Partial<AppProps> & DefaultWindowOptions): this;
 }
@@ -214,30 +228,33 @@ export declare class AppsConfig {
     constructor(options?: Partial<AppsConfigOptions>);
     get installedApps(): App<WindowProps>[];
     /**
-     * @param includeUninstalled Include apps that are not currently installed
+     * @param id - The ID of the app.
+     * @param includeUninstalled - Include apps that are not currently installed.
      */
     getAppById(id: string, includeUninstalled?: boolean): App | null;
     /**
-     * Get the app associated with a file extension
+     * Get the app associated with a file extension.
      */
     getAppByFileExtension(fileExtension: string): App | null;
     /**
-     * Get the app with a specific role
+     * Get the app with a specific role.
      */
     getAppByRole(role: string): App | null;
     /**
-     * Get all applications (including uninstalled apps) that belong to a category
+     * Get all applications (including uninstalled apps) that belong to a category.
      */
     getAppsByCategory(category: typeof APP_CATEGORIES[number]): App[];
 }
 
 export declare interface AppsConfigOptions {
     /**
-     * An array of applications
+     * An array of applications.
      */
     apps: App<WindowProps>[];
 }
 
+export declare const ASCII_LOGO = "\n              :.           \n             -==.          \n           .=====:         \n   ---::..:=======-.       \n   :===+=----------::..    \n    =+=---------------:..  \n    --------------------:. \n.:-+=----*###*--*####=---. \n:==+----#%+-+%#-##%*+----:.\n  .=----#%+-+%#-*+-%#+---:.\n   ==----*###*--*###*----. \n  ==+-------------------:. \n  ...::---------------:.   \n       .::---------::..    \n          ....::...        ";
+
 export declare const AUDIO_EXTENSIONS: string[];
 
 export declare function Button({ className, href, children, icon, target, ...props }: ButtonProps): JSX_2.Element;
@@ -245,12 +262,16 @@ export declare function Button({ className, href, children, icon, target, ...pro
 export declare interface ButtonProps {
     className?: string;
     href?: string;
-    icon?: IconProp;
+    icon?: IconDefinition;
     target?: HTMLAttributeAnchorTarget;
     children?: ReactNode;
     [key: string]: unknown;
 }
 
+declare type CategorizedOptions = Record<string, Record<string, ShortcutHandler>>;
+
+declare type CategorizedShortcuts = Record<string, Record<string, string[]>>;
+
 export declare const ClickAction: MemoExoticComponent<({ actionId, label, shortcut, disabled, onTrigger, icon }: ClickActionProps) => JSX_2.Element>;
 
 export declare interface ClickActionProps extends ActionProps {
@@ -258,13 +279,60 @@ export declare interface ClickActionProps extends ActionProps {
 }
 
 /**
- * Simulates closing the viewport by opening a blank page
- * @param name - Name of the app
+ * Simulates closing the viewport by opening a blank page.
+ * @param requireConfirmation - Whether to require confirmation before closing.
+ * @param name - Name of the app.
  */
 export declare function closeViewport(requireConfirmation: boolean | undefined, name: string): void;
 
 export declare const CODE_EXTENSIONS: string[];
 
+/**
+ * Defines a shell command, including its execution logic, arguments requirements, and manual page.
+ */
+export declare class Command {
+    #private;
+    options: Option_2[];
+    manual?: Manual;
+    requireArgs?: boolean;
+    requireOptions?: boolean;
+    /**
+     * The core logic to run when the command is invoked.
+     */
+    execute: Execute;
+    /**
+     * Sets the command name and initializes the default usage string if not already set.
+     */
+    setName(name?: string): Command;
+    get name(): string;
+    setExecute(execute: Execute): Command;
+    setRequireArgs(value: boolean): Command;
+    setRequireOptions(value: boolean): Command;
+    setManual({ purpose, usage, description, options }: Manual): Command;
+    /**
+     * Registers a new option/flag for this command.
+     */
+    addOption({ short, long, isInput }: Omit<Option_2, "isInput"> & {
+        isInput?: boolean;
+    }): Command;
+    /**
+     * Retrieves an option definition by either its short or long name.
+     */
+    getOption(key: string): Option_2 | undefined;
+}
+
+export declare type CommandOutput = number | undefined | void;
+
+export declare class CommandsManager {
+    static COMMANDS: Command[];
+    static addCommand(command: Command): void;
+    static find(name: string): Command | null;
+    static search(pattern: string): Command[];
+    static reload(): void;
+}
+
+export declare type ContextMenuHandler = (event: MouseEvent_2<HTMLElement, MouseEvent_2>, params?: object) => Modal;
+
 export declare function copyToClipboard(string: string, onSuccess?: (value: void) => void, onFail?: (value: void) => void): void;
 
 export declare function DefaultRoute(): JSX_2.Element;
@@ -275,7 +343,7 @@ export declare interface DefaultWindowOptions {
 }
 
 /**
- * Component that renders the wallpaper and desktop icons
+ * Component that renders the wallpaper and desktop icons.
  */
 export declare const Desktop: MemoExoticComponent<() => JSX_2.Element>;
 
@@ -287,13 +355,13 @@ export declare class DesktopConfig {
 
 export declare interface DesktopConfigOptions {
     /**
-     * The default size of the icons
+     * The default size of the icons.
      * @default 1
      */
     defaultIconSize: 0 | 1 | 2;
     /**
      * The defailt direction of the icons
-     * 0: vertical, 1: horizontal
+     * 0: vertical, 1: horizontal.
      * @default 0
      * */
     defaultIconDirection: 0 | 1;
@@ -302,32 +370,32 @@ export declare interface DesktopConfigOptions {
 export declare function DialogBox({ modal, params, children, ...props }: ModalProps): JSX_2.Element;
 
 /**
- * Component that displays the contents of a directory
+ * Component that displays the contents of a directory.
  */
 export declare function DirectoryList({ directory, showHidden, folderClassName, fileClassName, className, onContextMenuFile, onContextMenuFolder, onOpenFile, onOpenFolder, allowMultiSelect, onSelectionChange, ...props }: DirectoryListProps): ReactElement | null;
 
 export declare interface DirectoryListProps {
-    /** The directory to display */
+    /** The directory to display. */
     directory: VirtualFolder;
-    /** Whether to show hidden files and folders */
+    /** Whether to show hidden files and folders. */
     showHidden?: boolean;
-    /** `className` prop for folders */
+    /** `className` prop for folders. */
     folderClassName?: string;
-    /** `className` prop for files */
+    /** `className` prop for files. */
     fileClassName?: string;
-    /** `className` prop for this component */
+    /** `className` prop for this component. */
     className?: string;
-    /** Function that handles context menu interactions on files */
+    /** Function that handles context menu interactions on files. */
     onContextMenuFile?: FileEventHandler;
-    /** Function that handles context menu interactions on folders */
+    /** Function that handles context menu interactions on folders. */
     onContextMenuFolder?: FolderEventHandler;
-    /** Function that handles file opening events */
+    /** Function that handles file opening events. */
     onOpenFile?: FileEventHandler;
-    /** Function that handles folder opening events */
+    /** Function that handles folder opening events. */
     onOpenFolder?: FolderEventHandler;
-    /** Whether to allow multiple files and folders to be selected at the same time */
+    /** Whether to allow multiple files and folders to be selected at the same time. */
     allowMultiSelect?: boolean;
-    /** Function that handles selection changes */
+    /** Function that handles selection changes. */
     onSelectionChange?: (params: OnSelectionChangeParams) => void;
     [key: string]: unknown;
 }
@@ -343,37 +411,30 @@ export declare interface DropdownActionProps extends ActionProps {
 }
 
 /**
- * Component that opens a dropdown menu
+ * Component that opens a dropdown menu.
  */
 export declare function DropdownButton({ label, options, shortcuts }: DropdownButtonProps): JSX_2.Element;
 
 export declare interface DropdownButtonProps {
-    /** The label of the button */
+    /** The label of the button. */
     label: string;
-    /** The options in the dropdown menu mapped to the function that handles their selection */
-    options: Record<string, () => void>;
-    /** The keyboard shortcut for options in the dropdown menu */
+    /** The options in the dropdown menu mapped to the function that handles their selection. */
+    options?: Record<string, () => void>;
+    /** The keyboard shortcut for options in the dropdown menu. */
     shortcuts: Record<string, string[]>;
 }
 
-declare class EventEmitter<EventMap extends EventNamesMap> {
-    #private;
-    static EVENT_NAMES: EventNamesMap;
-    /**
-     * Add event listener for an event
-     */
-    on<Key extends keyof EventMap>(eventName: Key, callback: Listener): Listener;
-    /**
-     * Remove event listener for an event
-     */
-    off<Key extends keyof EventMap>(eventName: Key, callback: Listener): void;
-    /**
-     * Dispatch event
-     */
-    emit<Key extends keyof EventMap>(eventName: Key, data?: unknown): void;
-}
+export declare type Execute = (args: string[], context: ShellContext) => Promise<CommandOutput> | CommandOutput;
 
-declare type EventNamesMap = Record<string, string>;
+export declare const EXIT_CODE: {
+    readonly success: 0;
+    readonly generalError: 1;
+    readonly misuseOfBuiltins: 2;
+    readonly commandNotExecutable: 126;
+    readonly commandNotFound: 127;
+    readonly invalidExitArgument: 128;
+    readonly terminatedByCtrlC: 130;
+};
 
 export declare const FILE_SCHEMES: {
     external: string;
@@ -382,16 +443,20 @@ export declare const FILE_SCHEMES: {
 
 export declare type FileEventHandler = (event: Event, file: VirtualFile) => void;
 
+declare type FlatOptions = Record<string, ShortcutHandler>;
+
+declare type FlatShortcuts = Record<string, string[]>;
+
 export declare type FolderEventHandler = (event: Event, folder: VirtualFolder) => void;
 
 /**
  * Formats a shortcut (combination of keys) into a human-readable format.
  *
- * For a list of valid key values, refer to this page: <https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values>
+ * For a list of valid key values, refer to this page: <https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values>.
  */
 export declare function formatShortcut(shortcut: string[]): string;
 
-export declare function generateUrl(options: GenerateUrlParams): string;
+export declare function generateUrl(options?: GenerateUrlParams): string;
 
 export declare interface GenerateUrlParams {
     appId?: string;
@@ -402,10 +467,26 @@ export declare interface GenerateUrlParams {
 export declare function getViewportParams(): Record<string, string>;
 
 /**
- * Component that shows a header menu at the top of a window
+ * Component that shows a header menu at the top of a window.
  */
 export declare function HeaderMenu({ children, ...props }: ActionsProps): JSX_2.Element;
 
+/**
+ * Represents a single entry in the shell's output history.
+ */
+export declare interface HistoryEntry {
+    /** The text content to display. */
+    text?: string;
+    /** Whether this entry represents a user-inputted command. */
+    isCommand: boolean;
+    /** The raw string value of the command. */
+    value?: string;
+    /** If true, the terminal view should be cleared before rendering this entry. */
+    clear?: boolean;
+}
+
+export declare const HOSTNAME = "prozilla-os";
+
 declare function Image_2({ className, src, ...props }: ImageProps): JSX_2.Element;
 export { Image_2 as Image }
 
@@ -426,14 +507,14 @@ export declare interface ImageProps {
 }
 
 /**
- * Button component that handles single and double clicks
+ * Button component that handles single and double clicks.
  */
 export declare function Interactable({ onClick, onDoubleClick, children, ...props }: InteractableProps): JSX_2.Element;
 
 export declare interface InteractableProps {
-    /** Function that handles single clicks */
+    /** Function that handles single clicks. */
     onClick?: (event: MouseEvent) => void;
-    /** Function that handles double clicks */
+    /** Function that handles double clicks. */
     onDoubleClick?: (event: MouseEvent) => void;
     children: ReactNode;
     [key: string]: unknown;
@@ -441,7 +522,21 @@ export declare interface InteractableProps {
 
 export declare function isValidUrl(string: string): boolean;
 
-declare type Listener = (data: unknown) => void;
+/**
+ * Documentation metadata used by the `help` or `man` commands.
+ */
+export declare interface Manual {
+    /** A brief one-line summary of what the command does. */
+    purpose?: string;
+    /** A string representing the syntax (e.g., "ls [OPTION]... [FILE]..."). */
+    usage?: string;
+    /** A detailed explanation of the command's behavior. */
+    description?: string;
+    /** A mapping of option names to their descriptions for the help output. */
+    options?: object;
+}
+
+export declare const MAX_WIDTH = 50;
 
 export declare const MEDIA_EXTENSIONS: string[];
 
@@ -452,55 +547,55 @@ export declare class MiscConfig {
 
 export declare interface MiscConfigOptions {
     /**
-     * The maximum time between two clicks to register as a double click (in ms)
+     * The maximum time between two clicks to register as a double click (in ms).
      * @default 250
      * */
     doubleClickDelay: number;
 }
 
 /**
- * Represents a modal window
+ * Represents a modal window.
  */
 export declare class Modal {
     /**
-     * The size of this modal
+     * The size of this modal.
      * @default new Vector2(400, 200)
      */
     size: Vector2;
     /**
-     * The position of this modal
+     * The position of this modal.
      * @default new Vector2(300, 300)
      */
     position: Vector2;
     /**
-     * The icon of this modal
+     * The icon of this modal.
      * @default null
      */
     icon: string | null;
     /**
-     * The title of this modal
+     * The title of this modal.
      * @default null
      */
     title: string | null;
     /**
-     * The manager that handles all modals
+     * The manager that handles all modals.
      */
     modalsManager: ModalsManager | null;
     /**
-     * The content of this modal
+     * The content of this modal.
      * @default null
      */
     element: FC<ModalProps> | null;
     props: object;
     callback: ((...args: unknown[]) => void) | null;
-    /** The ID of this modal */
+    /** The ID of this modal. */
     id: number | null;
     /**
-     * Whether this modal can be dismissed (e.g., by pressing ESC)
+     * Whether this modal can be dismissed (e.g., by pressing ESC).
      * @default true
      */
     dismissible: boolean;
-    /** Timestamp of the most recent interaction with this modal */
+    /** Timestamp of the most recent interaction with this modal. */
     lastInteraction?: number;
     constructor(element: Modal["element"], callback?: Modal["callback"]);
     setIcon(icon: string): Modal;
@@ -545,44 +640,45 @@ export declare class ModalsConfig {
 
 export declare interface ModalsConfigOptions {
     /**
-     * Default size of a dialog box
+     * Default size of a dialog box.
      * @default new Vector2(400, 200)
      */
     defaultDialogSize: Vector2;
     /**
-     * Default size of a file selector
+     * Default size of a file selector.
      * @default new Vector2(700, 400)
      */
     defaultFileSelectorSize: Vector2;
 }
 
 /**
- * Manages the opening, closing and ordering of modals
+ * Manages the opening, closing and ordering of modals.
  */
 export declare class ModalsManager {
-    /** Maps every modal ID to the corresponding modal */
+    /** Maps every modal ID to the corresponding modal. */
     modals: Record<string, Modal>;
     containerRef?: MutableRefObject<HTMLElement>;
-    /** Function that handles changes to modals */
+    /** Function that handles changes to modals. */
     updateModals: (modals: ModalsManager["modals"]) => void;
     /**
-     * Opens a modal
-     * @param single - Set to false to preserve other open modals
+     * Opens a modal.
+     * @param modal - The modal to open.
+     * @param single - Set to false to preserve other open modals.
      */
     open(modal: Modal, single?: boolean): void;
     /**
-     * Closes a modal
-     * @param modalId The ID of the modal to close
+     * Closes a modal.
+     * @param modalId - The ID of the modal to close.
      */
     close(modalId: string | number, sendModalsUpdate?: boolean): void;
     /**
-     * Brings a modal into focus
-     * @param modalId The ID of the modal to bring into focus
+     * Brings a modal into focus.
+     * @param modalId - The ID of the modal to bring into focus.
      */
     focus(modalId: string): void;
     setUpdateModals(updateModals: ModalsManager["updateModals"]): void;
     /**
-     * Returns the IDs of all open modals
+     * Returns the IDs of all open modals.
      */
     get modalIds(): string[];
     static getModalIconUrl(name: string): string;
@@ -593,7 +689,7 @@ export declare const modalsManagerContext: Context<ModalsManagerState>;
 export declare type ModalsManagerState = ModalsManager | undefined;
 
 /**
- * Component that renders all active modals
+ * Component that renders all active modals.
  */
 export declare const ModalsView: MemoExoticComponent<() => JSX_2.Element>;
 
@@ -601,18 +697,18 @@ export declare function NoRoute(): JSX_2.Element;
 
 export declare interface NoRouteProps {
     /**
-     * Title of the route
+     * Title of the route.
      * @default "404: Not Found"
      */
     title: string;
 }
 
 export declare interface OnSelectionChangeParams {
-    /** The selected files */
+    /** The selected files. */
     files?: string[];
-    /** The selected folders */
+    /** The selected folders. */
     folders?: string[];
-    /** The directory the selection was made in */
+    /** The directory the selection was made in. */
     directory?: VirtualFolder;
 }
 
@@ -621,61 +717,96 @@ export declare function openUrl(url: string, target?: HTMLAttributeAnchorTarget)
 export declare type OpenWindowedModal = (params: OpenWindowedModalParams) => Modal;
 
 export declare interface OpenWindowedModalParams {
-    /** The ID of the associated app */
+    /** The ID of the associated app. */
     appId?: string;
-    /** The URL of the icon of the modal */
+    /** The URL of the icon of the modal. */
     iconUrl?: string;
-    /** The title of the modal */
+    /** The title of the modal. */
     title?: string;
-    /** The size of the modal */
-    size: Vector2;
-    /** The modal component */
+    /** The size of the modal. */
+    size?: Vector2;
+    /** The modal component. */
     Modal: FC<ModalProps>;
     single?: boolean;
     fullscreen?: WindowProps["fullscreen"];
 }
 
+/**
+ * Represents a command-line flag or parameter.
+ */
+declare interface Option_2 {
+    /** The full name of the option (e.g., "all" for --all). */
+    long: string;
+    /** The single-character alias (e.g., "a" for -a). */
+    short: string;
+    /** If true, the shell expects a value to follow this option (e.g., --file <name>). */
+    isInput: boolean;
+}
+export { Option_2 as Option }
+
 export declare type OptionalStringProperty = string | null | undefined;
 
 /**
- * Component that calls a function when the user clicks outside of it
+ * Component that calls a function when the user clicks outside of it.
  */
 export declare const OutsideClickListener: MemoExoticComponent<({ onOutsideClick, children }: OutsideClickListenerProps) => JSX_2.Element>;
 
 export declare interface OutsideClickListenerProps {
-    /** Function that handles clicks outside of this component */
+    /** Function that handles clicks outside of this component. */
     onOutsideClick: (event: Event) => void;
     children: ReactNode;
 }
 
 /**
- * Component that renders a progress bar
+ * Represents an active or pending process within the shell.
+ */
+export declare interface Process extends ProcessIO {
+    /** The executable name or alias being invoked. */
+    commandName: string;
+    /** Array of string arguments passed to the command. */
+    args: string[];
+}
+
+/**
+ * Standard input, output, and error streams for a process.
+ */
+export declare interface ProcessIO {
+    /** The stream used to receive input data. */
+    stdin: Stream;
+    /** The stream used to output standard data. */
+    stdout: Stream;
+    /** The stream used to output error messages. */
+    stderr: Stream;
+}
+
+/**
+ * Component that renders a progress bar.
  */
 export declare function ProgressBar({ fillPercentage, fillColor, backgroundColor, align, className }: ProgressBarProps): JSX_2.Element;
 
 export declare interface ProgressBarProps {
-    /** The amount of progress, as a percentage */
+    /** The amount of progress, as a percentage. */
     fillPercentage: number;
-    /** The CSS color to use for the filled part of the progress bar */
+    /** The CSS color to use for the filled part of the progress bar. */
     fillColor?: string;
-    /** The CSS background color of the progress bar */
+    /** The CSS background color of the progress bar. */
     backgroundColor?: string;
     align?: "left";
-    /** `className` prop for the progress bar */
+    /** `className` prop for the progress bar. */
     className?: string;
 }
 
 /**
- * Main component that contains everything
+ * Main component that contains everything .
  */
 export declare const ProzillaOS: NamedExoticComponent<ProzillaOSProps>;
 
 export declare interface ProzillaOSProps {
-    /** The name of the system */
+    /** The name of the system. */
     systemName?: string;
-    /** The tagline/short description of the system */
+    /** The tagline/short description of the system. */
     tagLine?: string;
-    /** The system configuration */
+    /** The system configuration. */
     config?: {
         apps?: Partial<AppsConfigOptions>;
         desktop?: Partial<DesktopConfigOptions>;
@@ -692,26 +823,16 @@ export declare interface ProzillaOSProps {
 
 export declare function RadioAction({ actionId, options, initialIndex, onTrigger }: RadioActionProps): ReactElement;
 
-/**
- * @param {object} props
- * @param {string} props.actionId
- * @param {{
-         * 	label: string,
-         * 	shortcut: string[]
-         * }[]} props.options
- * @param {number} props.initialIndex
- * @param {Function} props.onTrigger
- */
 export declare interface RadioActionProps extends ActionProps {
     options: {
         label: string;
         shortcut?: string[];
     }[];
-    initialIndex: number;
+    initialIndex?: number;
 }
 
 /**
- * Reloads the viewport
+ * Reloads the viewport.
  */
 export declare function reloadViewport(): void;
 
@@ -723,64 +844,95 @@ export declare function Router({ path, homePage, fallbackPage, children }: Route
 
 export declare interface RouterProps {
     path?: string;
-    homePage?: JSX.Element;
-    fallbackPage?: JSX.Element;
+    homePage?: ReactElement;
+    fallbackPage?: ReactElement;
     children?: ReactElement;
 }
 
 export declare class Settings {
     #private;
+    /**
+     * The virtual path of the settings file.
+     */
     path: string;
-    file: VirtualFile;
+    /**
+     * The settings file.
+     */
+    file: VirtualFile | null;
     xmlDoc?: Document;
+    /**
+     * Virtual path to the desktop settings.
+     */
+    static readonly DESKTOP: string;
+    /**
+     * Virtual path to the taskbar settings.
+     */
+    static readonly TASKBAR: string;
+    /**
+     * Virtual path to the apps settings.
+     */
+    static readonly APPS: string;
+    /**
+     * Virtual path to the theme settings.
+     */
+    static readonly THEME: string;
+    /**
+     * Virtual path to the virtual drive settings.
+     */
+    static readonly VIRTUAL_DRIVE: string;
     constructor(virtualRoot: VirtualRoot, path: string);
     /**
-     * Reads the xml doc from the given path and assigns it to itself
+     * Reads the xml doc from the given path and assigns it to itself.
      */
     read(): Promise<void>;
     write(): void;
     /**
-     * Checks if xml doc is missing
+     * Checks if xml doc is missing.
      */
     isMissingXmlDoc(): Promise<boolean>;
     /**
-     * Gets a value by a given key if it exists and optionally calls a callback function whenever the value changes
-     * @param key The key of the setting
-     * @param callback The callback function to call whenever the value changes
+     * Gets a value by a given key if it exists and optionally calls a callback function whenever the value changes.
+     * @param key - The key of the setting.
+     * @param callback - The callback function to call whenever the value changes.
      */
     get(key: string, callback?: (value: string) => void): Promise<{
         value: string | null;
-        listener?: Listener;
+        listener?: SettingsListener;
     }>;
     /**
-     * Gets a value by a given key as a boolean
+     * Gets a value by a given key as a boolean.
      */
     getBool(key: string, callback?: (value: boolean) => void): Promise<{
         value: boolean | null;
-        listener?: Listener;
+        listener?: SettingsListener;
     }>;
     /**
-     * Gets a value by a given key as an integer
+     * Gets a value by a given key as an integer.
      */
     getInt(key: string, callback?: (value: number) => void): Promise<{
         value: number | null;
-        listener?: Listener;
+        listener?: SettingsListener;
     }>;
     /**
-     * Sets the value associated with a given key
-     * @param key The key of the setting
-     * @param value The new value
+     * Sets the value associated with a given key.
+     * @param key - The key of the setting.
+     * @param value - The new value.
      */
     set(key: string, value: string): Promise<void>;
     /**
-     * Removes a listener from the settings file
-     * @param listener The listener to remove
+     * Removes a listener from the settings file.
+     * @param listener - The listener to remove.
      */
-    removeListener(listener: Listener): void;
+    removeListener(listener: SettingsListener): void;
 }
 
+export declare type SettingsListener = Listener<VirtualFileEvents, "contentChange">;
+
 export declare class SettingsManager {
     #private;
+    /**
+     * @deprecated - Use constants from {@link Settings} instead.
+     */
     static VIRTUAL_PATHS: {
         [s: string]: string;
     };
@@ -800,87 +952,371 @@ export declare function setViewportTitle(title: string): void;
 
 export declare function Share({ modal, params, ...props }: ModalProps): JSX_2.Element;
 
-declare class Skin {
-    systemIcon: SkinOptions["systemIcon"];
-    appIcons: SkinOptions["appIcons"];
-    appNames: SkinOptions["appNames"];
-    wallpapers: SkinOptions["wallpapers"];
-    defaultWallpaper: SkinOptions["defaultWallpaper"];
-    fileIcons: SkinOptions["fileIcons"];
-    folderIcons: SkinOptions["folderIcons"];
-    loadStyleSheet: SkinOptions["loadStyleSheet"];
-    defaultTheme: SkinOptions["defaultTheme"];
-    constructor(options?: Partial<SkinOptions>);
+/**
+ * A Unix-like shell emulator that handles command parsing, environment management,
+ * autocompletion, and process I/O.
+ */
+export declare class Shell {
+    /** The reactive state of this shell. */
+    state: ShellState;
+    /** The configuration used to initialize this shell. */
+    config: ShellConfig;
+    /** The environment variable manager for this shell. */
+    env: ShellEnvironment;
+    /** The logic handler for parsing and executing command strings. */
+    interpreter: ShellInterpreter;
+    static readonly COMMAND_NOT_FOUND_ERROR = "Command not found";
+    static readonly MISSING_ARGS_ERROR = "requires at least 1 argument";
+    static readonly MISSING_OPTIONS_ERROR = "requires at least 1 option";
+    static readonly COMMAND_FAILED_ERROR = "Command failed";
+    static readonly USAGE_ERROR = "Incorrect usage";
+    static readonly INVALID_PATH_ERROR = "No such file or directory";
+    static readonly SUDO_COMMAND = "sudo";
+    /** Regex used to strip specific ANSI escape codes from the TTY buffer. */
+    static readonly STRIP_ANSI_REGEX: RegExp;
+    constructor(config: ShellConfig);
+    /**
+     * Sends a signal to the shell or the currently active foreground process.
+     * @param signal - The signal to send. Defaults to `"SIGTERM"`.
+     */
+    terminate(signal?: StreamSignal): void;
+    /**
+     * Convenience method to send the `SIGINT` (Interrupt) signal.
+     * @see {@link Shell.terminate}
+     */
+    interrupt(): void;
+    /**
+     * Convenience method to send the `SIGKILL` (Kill) signal, closing the shell.
+     * @see {@link Shell.terminate}
+     */
+    kill(): void;
+    /**
+     * Recalculates the prompt string based on the current user, hostname, and working directory.
+     */
+    updatePrompt(): void;
+    /**
+     * Updates the text in the current input line.
+     * @param value - The new string value or a function that receives the previous value.
+     */
+    setLine(value: string | ((prev: string) => string)): void;
+    /**
+     * Appends a new entry to the terminal history.
+     * @param entry - The history entry to add.
+     */
+    pushHistory(entry: HistoryEntry): void;
+    /**
+     * Writes raw text to the shell, handling ANSI escape codes for screen clearing and alt buffers.
+     * @param text - The string data to write to the TTY.
+     */
+    write(text: string): void;
+    /**
+     * Clears the current input line and executes the given command string.
+     * @param input - The command string to execute.
+     * @returns A promise that resolves with the final exit code of the execution.
+     */
+    run(input: string): Promise<number>;
+    /**
+     * Clears the current input line and resets the history search offset.
+     */
+    clearLine(): void;
+    /**
+     * Navigates through command history.
+     * @param direction - Positive to go back in time, negative to go forward.
+     */
+    historySearch(direction: number): void;
+    /**
+     * Changes the current working directory and updates `PWD`/`OLDPWD` environment variables.
+     * @param directory - The virtual folder to switch to.
+     */
+    setWorkingDirectory(directory: VirtualFolder): void;
+    /**
+     * Calculates possible completions for the current input based on commands and file paths.
+     * @returns An array of string suggestions.
+     */
+    getCompletions(): string[];
+    /**
+     * Performs an auto-completion action. If one match is found, it completes the line.
+     * If multiple are found, it lists them in the history.
+     */
+    autoComplete(): void;
+    /**
+     * Utility to write a formatted error message to a stream and return an exit code.
+     * @param stream - The stream to receive the error output.
+     * @param commandName - The name of the command reporting the error.
+     * @param error - A single string or array of strings representing the error message.
+     * @param exitCode - The numerical exit code to return.
+     * @returns `exitCode`.
+     */
+    static writeError(stream: Stream, commandName: string, error?: string | string[], exitCode?: number): number;
+    /**
+     * Executes a frame-based animation in the terminal using the Alternate Screen Buffer.
+     * @returns A promise that resolves when the animation is stopped.
+     */
+    static animate({ stdout, stdin, render, delay, clear, stopOnBlank }: Pick<ShellContext, "stdout" | "stdin"> & {
+        /** The function that renders each frame. */
+        render: (frame: number) => string;
+        /** The delay between each frame, in ms. */
+        delay: number;
+        /** Whether to clear the terminal before each frame. */
+        clear?: boolean;
+        /** Whether to stop the animation when the rendered frame is blank. */
+        stopOnBlank?: boolean;
+    }): Promise<0>;
+    /**
+     * Reads input data. If `rawLine` is provided, it processes it immediately via the callback.
+     * Otherwise, it waits for data from the `stdin` stream.
+     * @param rawLine - The pre-provided input string.
+     * @param stdin - The input stream to fall back on.
+     * @param callback - Function to process the collected input data.
+     */
+    static readInput(rawLine: string, stdin: Stream, callback: (data: string) => CommandOutput): Promise<CommandOutput>;
+}
+
+/**
+ * Configuration options for initializing a new Shell instance.
+ */
+export declare interface ShellConfig {
+    /** The application instance that owns and manages this shell. */
+    app?: App;
+    /** The initial working directory path (e.g., "~" or "/bin"). */
+    path?: string;
+    /** A string to pre-fill the shell input with. */
+    input?: string;
+    virtualRoot: VirtualRoot;
+    systemManager: SystemManager;
+    settingsManager: SettingsManager;
+    /** Callback function to trigger when the shell process should be terminated. */
+    exit: () => void;
+    /** A reactive reference containing the current terminal dimensions in rows and columns. */
+    sizeRef: {
+        current: Vector2;
+    };
+    /** Optional initial environment variables to populate the shell with. */
+    env?: Record<string, string>;
+}
+
+/**
+ * The context object provided to command execution functions.
+ */
+export declare interface ShellContext extends ProcessIO {
+    /** Reference to the parent Shell instance. */
+    shell: Shell;
+    /** The directory where the command was executed. */
+    workingDirectory: VirtualFolder;
+    /** The name of the user executing the command. */
+    username: string;
+    /** The hostname of the virtual system. */
+    hostname: string;
+    /** The full, unparsed command line string (excluding pipes/redirects). */
+    rawLine: string;
+    /** Array of parsed flags in their short form (e.g., ["l", "a"]). */
+    options: string[];
+    /**
+     * Function to kill the shell session.
+     * @see {@link Shell.kill}
+     */
+    exit: () => void;
+    /** Map of option keys in their short form to their provided values. */
+    inputs: Record<string, string>;
+    /** Millisecond timestamp of when the command was started. */
+    timestamp: number;
+    virtualRoot: VirtualRoot;
+    settingsManager: SettingsManager;
+    systemManager: SystemManager;
+    /** The owning application, if any. */
+    app?: App;
+    /** The current dimensions of the terminal window. */
+    readonly size: Vector2;
+    /** The scoped environment variables for this process. */
+    env: ShellEnvironment;
 }
 
-declare interface SkinOptions {
+/**
+ * Manages environment variabels for {@link Shell}.
+ */
+export declare class ShellEnvironment {
+    store: Record<string, string>;
+    parent: ShellEnvironment | null;
+    exportedKeys: Set<string>;
+    static readonly USER = "USER";
+    static readonly HOSTNAME = "HOSTNAME";
+    static readonly WORKING_DIRECTORY = "PWD";
+    static readonly PREVIOUS_WORKING_DIRECTORY = "OLDPWD";
+    static readonly EXIT_CODE = "?";
+    static readonly ARGUMENT_COUNT = "#";
+    static readonly PROCESS_ID = "$";
+    /** List of variables that should never be exported. */
+    static readonly INTERNAL_VARS: string[];
+    constructor(initialVars?: Record<string, string>, parent?: ShellEnvironment | null);
+    get(key: string): string | undefined;
+    set(key: string, value: string, isExported?: boolean): void;
     /**
-     * SVG icon for the system
-     * @default
-     * "https://os.prozilla.dev/icon.svg"
+     * Marks an existing variable as exported.
      */
-    systemIcon: string;
+    export(key: string): void;
     /**
-     * Replacements for app icons based on app id
+     * Replaces variable placeholders in a string with their corresponding values.
      */
-    appIcons?: {
-        [key: string]: string;
-    };
+    expand(input: string): string;
     /**
-     * Replacements for app names based on app id
+     * Parses an assignment string (e.g., KEY=VALUE) and updates the environment.
+     * @returns `true` if the string was a valid assignment.
      */
-    appNames?: {
-        [key: string]: string;
-    };
+    parseAssignment(input: string): boolean;
     /**
-     * Array of URLs of wallpaper images
+     * Returns only variables that are marked for export.
      */
-    wallpapers: string[];
+    get exportedVariables(): Record<string, string>;
     /**
-     * URL of default wallpaper image
-     * @default
-     * "https://os.prozilla.dev/assets/wallpapers/vibrant-wallpaper-blue-purple-red.png"
+     * Returns all variables visible to this scope (including internal).
      */
-    defaultWallpaper: string;
+    get variables(): Record<string, string>;
     /**
-     * URLs of icons for types of files
+     * Creates a child scope for subshells or command execution.
      */
-    fileIcons: {
-        generic: string;
-        info?: string;
-        text?: string;
-        code?: string;
-        external?: string;
-        video?: string;
-        audio?: string;
-    };
+    fork(): ShellEnvironment;
+}
+
+/**
+ * Handles the parsing, expansion, and execution of shell commands and scripts.
+ * Manages the process pipeline and stream redirection.
+ */
+export declare class ShellInterpreter {
+    private shell;
+    pipeline: Process[];
+    constructor(shell: Shell);
     /**
-     * URLs of icons for types of folders
+     * Sends a termination signal to all processes currently in the pipeline.
+     * @param signal - The signal to send.
      */
-    folderIcons: {
-        generic: string;
-        images?: string;
-        text?: string;
-        link?: string;
-        video?: string;
-        audio?: string;
-    };
+    terminatePipeline(signal: StreamSignal): void;
+    /**
+     * Parses and executes a shell script.
+     * @param script - The script content or a virtual file.
+     * @returns The exit code of the last command executed in the script.
+     */
+    executeScript(script: string | VirtualFile): Promise<number>;
+    /**
+     * Parses and executes an input string, handling environment expansion and piping.
+     * @param input - The raw command line string.
+     * @param streams - Optional output streams to override default TTY behavior.
+     * @returns A promise that resolves with the final exit code of the execution.
+     */
+    execute(input: string, streams?: {
+        stdout?: Stream;
+        stderr?: Stream;
+    }): Promise<number>;
     /**
-     * Function that dynamically imports style sheet
+     * Resolves a command, parses flags/options, and executes the command logic.
+     * @returns The resulting exit code from the command execution.
      */
-    loadStyleSheet?: () => void;
+    spawn({ stdin, stdout, stderr, commandName, args }: Process): Promise<number>;
     /**
-     * Default theme
+     * Splits a command string into an array of arguments, respecting single and double quotes.
      */
-    defaultTheme?: Theme;
+    static parseCommand(input: string): string[];
 }
 
+/**
+ * The internal reactive state of the shell.
+ */
+export declare interface ShellState {
+    /** An array of all past outputs and commands displayed in the terminal. */
+    history: HistoryEntry[];
+    /** The current, unsubmitted text in the input line. */
+    line: string;
+    /** Current position in the history search (0 is the current line). */
+    historyOffset: number;
+    /** The current directory the shell is operating within. */
+    workingDirectory: VirtualFolder;
+    /** The formatted prompt string (e.g., "user@host:~$ "). */
+    prompt: string;
+    /** The current active input stream for a running process. */
+    stream: Stream | null;
+    /** Temporary storage for data written to the terminal while a stream is active. */
+    ttyBuffer: string | null;
+    /** Indicates if a process has requested the Alternate Screen Buffer (e.g., a text editor). */
+    isUsingAltScreen: boolean;
+    /** A reactive view of the current environment variables. */
+    env: Record<string, string>;
+}
+
+declare type ShortcutHandler = (event: KeyboardEvent) => void;
+
 export declare function StandaloneRoute({ app }: StandaloneRouteProps): JSX_2.Element;
 
 export declare interface StandaloneRouteProps {
     app: App;
 }
 
+/**
+ * A wrapper for {@link localStorage} with additional functionality like compression and a size limit.
+ */
+declare class Storage_2 {
+    /**
+     * Enables compression of values stored in this storage.
+     * @default false
+     */
+    enableCompression: boolean;
+    /**
+     * The prefix to prepend to keys.
+     * @default undefined
+     */
+    prefix: string | undefined;
+    /**
+     * The maximum amount of bytes of a value in this storage.
+     */
+    static readonly MAX_BYTES = 5000000;
+    static readonly COMPRESSED_PREFIX = "\uE000";
+    static readonly UNCOMPRESSED_PREFIX = "\uE001";
+    /**
+     * Stores a key and value pair in this storage.
+     * @param key - The key to store.
+     * @param value - The value to store.
+     */
+    store(key: string, value: string): void;
+    /**
+     * Loads a value associated with the given key.
+     * @param key - The key of the item.
+     * @returns The value of the item.
+     */
+    load(key: string): string | null;
+    /**
+     * Replaces the key of an item if it exists.
+     * @param oldKey - The key to replace.
+     * @param newKey - The new key.
+     */
+    rename(oldKey: string, newKey: string): this;
+    /**
+     * Removes the item with the given key from this storage.
+     * @param key - The key of the item.
+     */
+    remove(key: string): this;
+    /**
+     * Clears all items stored in this storage.
+     */
+    clear(): this;
+    /**
+     * Returns the byte size of a key and value pair.
+     * @param key - The key of the item.
+     * @param value - The value of the item.
+     */
+    getItemByteSize(key: string, value: string): number;
+    getEncodedByteSize(string: string | null): number;
+    encode(string: string): {
+        result: string;
+        size: number;
+    };
+    decode(string: string): string;
+    setPrefix(prefix?: string): this;
+    static getByteSize(string: string | null): number;
+    static byteToKilobyte(bytes: number): number;
+}
+export { Storage_2 as Storage }
+
+/**
+ * @deprecated Use {@link Storage} instead.
+ */
 declare class StorageManager_2 {
     static MAX_BYTES: number;
     static store(key: string, value: string): void;
@@ -891,11 +1327,63 @@ declare class StorageManager_2 {
 }
 export { StorageManager_2 as StorageManager }
 
+/**
+ * A communication channel for process I/O, supporting event-based data transmission,
+ * signaling, and piping between streams.
+ */
+export declare class Stream<T = string> extends EventEmitter<StreamEvents<T>> {
+    enabled: boolean;
+    static readonly DATA_EVENT = "data";
+    static readonly START_EVENT = "start";
+    static readonly STOP_EVENT = "stop";
+    static readonly SIGNAL_EVENT = "signal";
+    /**
+     * Activates the stream and notifies listeners.
+     */
+    start(callback?: (stream: this) => void): this;
+    /**
+     * Deactivates the stream. Subsequent calls to {@link Stream.write} will be ignored.
+     */
+    stop(): this;
+    /**
+     * Emits a control signal. Standard termination signals will automatically stop the stream.
+     */
+    signal(signal: StreamSignal): this;
+    /**
+     * Broadcasts data to all listeners if the stream is enabled.
+     */
+    write(data: T): this;
+    /**
+     * Forwards data, stop events, and signals from this stream to another.
+     * @param destination - The stream that will receive the forwarded data.
+     * @returns The destination stream to allow for chainable piping.
+     */
+    pipe(destination: Stream<T>): Stream<T>;
+    /**
+     * Returns a promise that resolves when the stream is stopped.
+     */
+    wait(): Promise<void>;
+    /**
+     * Returns a promise that resolves when the stream is stopped.
+     * @param value - Value to return when the promise resolves.
+     */
+    wait<U>(value: U): Promise<U>;
+}
+
+export declare interface StreamEvents<T = string> {
+    data: [T];
+    start: [];
+    stop: [];
+    signal: [StreamSignal];
+}
+
+export declare type StreamSignal = "SIGINT" | "SIGKILL" | "SIGTERM" | "SIGINFO";
+
 export declare class SystemManager {
     #private;
-    /** The name of the system */
+    /** The name of the system. */
     readonly systemName: string;
-    /** The tagline/short description of the system */
+    /** The tagline/short description of the system. */
     readonly tagLine: string;
     readonly skin: Skin;
     readonly appsConfig: AppsConfig;
@@ -906,6 +1394,7 @@ export declare class SystemManager {
     readonly trackingConfig: TrackingConfig;
     readonly windowsConfig: WindowsConfig;
     readonly virtualDriveConfig: VirtualDriveConfig;
+    readonly storage: Storage_2;
     constructor({ systemName, tagLine, skin, desktopConfig, appsConfig, miscConfig, modalsConfig, taskbarConfig, trackingConfig, windowsConfig, virtualDriveConfig, }: SystemManagerParams);
     private loadSkin;
     getUptime(precision?: number): string;
@@ -928,7 +1417,7 @@ export declare interface SystemManagerParams {
 }
 
 /**
- * Component that renders the start and search menus, pinned applications and various indicators
+ * Component that renders the start and search menus, pinned applications and various indicators.
  */
 export declare const Taskbar: MemoExoticComponent<() => JSX_2.Element>;
 
@@ -939,7 +1428,7 @@ export declare class TaskbarConfig {
 
 export declare interface TaskbarConfigOptions {
     /**
-     * Height of the taskbar in CSS pixels
+     * Height of the taskbar in CSS pixels.
      * @default 3 * 16
      */
     height: number;
@@ -951,23 +1440,14 @@ export declare interface TextDisplayProps {
     children: ReactNode;
 }
 
-declare enum Theme {
-    Dark = 0,
-    Light = 1,
-    Cherry = 2,
-    Mango = 3,
-    Aqua = 4,
-    Grape = 5
-}
-
 export declare class TimeManager {
     static START_DATE: Date;
     /**
-     * Resets the time
+     * Resets the time.
      */
     static reset(): void;
     /**
-     * Get the current uptime
+     * Get the current uptime.
      */
     static getUptime(precision?: number): string;
 }
@@ -975,7 +1455,7 @@ export declare class TimeManager {
 export declare function ToggleAction({ actionId, label, shortcut, initialValue, onTrigger }: ToggleActionProps): ReactElement;
 
 export declare interface ToggleActionProps extends ActionProps {
-    initialValue: boolean;
+    initialValue?: boolean;
 }
 
 export declare class TrackingConfig {
@@ -986,11 +1466,11 @@ export declare class TrackingConfig {
 
 export declare interface TrackingConfigOptions {
     /**
-     * Enable tracking
+     * Enable tracking.
      * @default true
      */
     enabled: boolean;
-    /** Google Analytics measurement ID */
+    /** Google Analytics measurement ID. */
     GAMeasurementId: string;
 }
 
@@ -1006,139 +1486,156 @@ export declare const TrackingManagerContext: Context<TrackingManagerState>;
 
 export declare type TrackingManagerState = TrackingManager | undefined;
 
-/** Returns a function that opens an alert modal */
+/** Returns a function that opens an alert modal. */
 export declare function useAlert(): {
     alert: (params: AlertParams) => void;
 };
 
 /**
- * Returns the folder associated with a given app
+ * Returns the folder associated with a given app.
  */
 export declare function useAppFolder(app?: App): VirtualFolder | null;
 
 /**
- * Returns the boolean value of a setting and a function to update it
- * @param path The path of the settings file
- * @param key The key of the setting
- * @param defaultValue The default value of the setting
- * @returns The boolean value of a setting and a function to update it
+ * Returns the boolean value of a setting and a function to update it.
+ * @param path - The path of the settings file.
+ * @param key - The key of the setting.
+ * @param defaultValue - The default value of the setting.
+ * @returns The boolean value of a setting and a function to update it.
  */
 export declare function useBoolSetting(path: SettingsPath, key: string, defaultValue?: boolean): [boolean, (value: string | boolean) => void];
 
 /**
- * Combine class names and an optional static class name
+ * Combines class names and an optional static class name.
+ * @param classNames - The class names to combine.
+ * @param block - The name of the block.
+ * @param element - The name of the element.
+ * @param modifier - The name of the modifier(s).
  */
 export declare function useClassNames(classNames: (string | undefined)[], block?: string, element?: string, modifier?: string | string[]): string;
 
 /**
- * Creates a function that handles the opening of a custom context menu and a component that listens for keyboard shortcuts
+ * Creates a function that handles the opening of a custom context menu and a component that listens for keyboard shortcuts.
  */
 export declare function useContextMenu({ Actions }: UseContextMenuParams): {
-    onContextMenu: (event: MouseEvent_2<HTMLElement, MouseEvent_2>, params?: object) => Modal;
+    onContextMenu: ContextMenuHandler;
     ShortcutsListener: () => JSX_2.Element;
 };
 
 export declare interface UseContextMenuParams {
-    /** The component with the actions of the context menu */
+    /** The component with the actions of the context menu. */
     Actions: FC<ActionsProps>;
 }
 
 /**
- * Returns an object that handles stateful history with undo and redo methods
+ * Returns an object that handles stateful history with undo and redo methods.
  */
 export declare function useHistory<Type>(initialState: Type): {
-    /** The entries of the history */
+    /** The entries of the history. */
     history: Type[];
-    /** The index of the active entry in list of entries */
+    /** The index of the active entry in list of entries. */
     stateIndex: number;
-    /** Adds a new entry to the history */
+    /** Adds a new entry to the history. */
     pushState: (state: Type) => void;
-    /** Moves backwards in the history */
+    /** Moves backwards in the history. */
     undo: () => void;
-    /** Moves forwards in the history */
+    /** Moves forwards in the history. */
     redo: () => void;
     undoAvailable: boolean;
     redoAvailable: boolean;
 };
 
 /**
- * Returns the integer value of a setting and a function to update it
- * @param path The path of the settings file
- * @param key The key of the setting
- * @param defaultValue The default value of the setting
- * @returns The integer value of a setting and a function to update it
+ * Returns the integer value of a setting and a function to update it.
+ * @param path - The path of the settings file.
+ * @param key - The key of the setting.
+ * @param defaultValue - The default value of the setting.
+ * @returns The integer value of a setting and a function to update it.
  */
 export declare function useIntSetting(path: SettingsPath, key: string, defaultValue?: number): [number, (value: string | number) => void];
 
 /**
- * Creates listeners for `"keydown"` and `"keyup"` events
+ * Creates listeners for `"keydown"` and `"keyup"` events.
  */
 export declare function useKeyboardListener({ onKeyDown, onKeyUp }: UseKeyboardListenerParams): void;
 
 export declare interface UseKeyboardListenerParams {
-    /** Function that handles `"keydown"` events */
+    /** Function that handles `"keydown"` events. */
     onKeyDown?: (event: KeyboardEvent) => void;
-    /** Function that handles `"keyup"` events */
+    /** Function that handles `"keyup"` events. */
     onKeyUp?: (event: KeyboardEvent) => void;
 }
 
 /**
- * Returns the items of a list value of a setting and a function to update it
- * @param path The path of the settings file
- * @param key The key of the setting
- * @param defaultValue The default value of the setting
- * @returns The items of a list value of a setting and a function to update it
+ * A hook that initializes a ref lazily.
+ * Ensures the initializer function is only called once during the initial mount.
+ * @param create - A factory function that returns the initial value.
+ */
+export declare function useLazyRef<T>(create: () => T): MutableRefObject<T>;
+
+/**
+ * Returns the items of a list value of a setting and a function to update it.
+ * @param path - The path of the settings file.
+ * @param key - The key of the setting.
+ * @param defaultValue - The default value of the setting.
+ * @returns The items of a list value of a setting and a function to update it.
  */
 export declare function useListSetting(path: SettingsPath, key: string, defaultValue?: string[]): [string[], (value: string | string[]) => void];
 
+export declare function useManualContextMenu(): {
+    openContextMenu: (position: Vector2, Actions: FC<ActionsProps>, params?: object) => Modal;
+};
+
 export declare function useModalsManager(): ModalsManagerState;
 
 /**
- * Creates listeners for `"mousedown"`, `"mouseup"`, `"click"` and `"contextmenu"` events
+ * Creates listeners for `"mousedown"`, `"mouseup"`, `"click"` and `"contextmenu"` events.
  */
 export declare function useMouseListener({ onMouseDown, onMouseUp, onClick, onContextMenu }: UseMouseListenerParams): void;
 
 export declare interface UseMouseListenerParams {
-    /** Function that handles `"mousedown"` events */
-    onMouseDown: EventListener;
-    /** Function that handles `"mouseup"` events */
-    onMouseUp: EventListener;
-    /** Function that handles `"click"` events */
-    onClick: EventListener;
-    /** Function that handles `"contextmenu"` events */
-    onContextMenu: EventListener;
+    /** Function that handles `"mousedown"` events. */
+    onMouseDown?: EventListener;
+    /** Function that handles `"mouseup"` events. */
+    onMouseUp?: EventListener;
+    /** Function that handles `"click"` events. */
+    onClick?: EventListener;
+    /** Function that handles `"contextmenu"` events. */
+    onContextMenu?: EventListener;
 }
 
+export declare const USERNAME = "user";
+
 /**
- * Returns the ideal orientation of an element so that it does not go outside of the screen
+ * Returns the ideal orientation of an element so that it does not go outside of the screen.
  */
 export declare function useScreenBounds({ avoidTaskbar }: {
-    /** Whether to avoid the task bar */
+    /** Whether to avoid the task bar. */
     avoidTaskbar: boolean;
 }): {
-    /** The React ref of the element */
-    ref: Ref<HTMLElement>;
+    /** The React ref of the element. */
+    ref: MutableRefObject<HTMLElement | null>;
     initiated: boolean;
-    /** Whether the element should align to the left (`true`) or right (`false`) */
+    /** Whether the element should align to the left (`true`) or right (`false`). */
     alignLeft: boolean;
-    /** Whether the element should align to the top (`true`) or bottom (`false`) */
+    /** Whether the element should align to the top (`true`) or bottom (`false`). */
     alignTop: boolean;
 };
 
 /**
- * Returns the width and height of the element with ID "root"
+ * Returns the width and height of the element with ID "root".
  */
 export declare function useScreenDimensions(): [screenWidth: number | null, screenHeight: number | null];
 
-export declare function useScrollWithShadow(params: UseScrollWithShadowParams): {
+export declare function useScrollWithShadow<T extends HTMLElement = HTMLElement>(params?: UseScrollWithShadowParams<T>): {
     boxShadow: string;
-    onUpdate: (event: Event | {
-        target: HTMLElement;
+    onUpdate: (event: UIEvent_2<T> | {
+        target: T | null;
     }) => void;
 };
 
-export declare interface UseScrollWithShadowParams {
-    ref?: MutableRefObject<HTMLElement>;
+export declare interface UseScrollWithShadowParams<T extends HTMLElement = HTMLElement> {
+    ref?: RefObject<T | null>;
     horizontal?: boolean;
     dynamicOffset?: boolean;
     dynamicOffsetFactor?: number;
@@ -1156,40 +1653,77 @@ export declare interface UseScrollWithShadowParams {
 }
 
 /**
- * Returns the value of a setting and a function to update it
- * @param path The path of the settings file
- * @param key The key of the setting
- * @param defaultValue The default value of the setting
- * @param parse A function that converts a string to a value
- * @param stringify A function that converts a value to a string
- * @returns The value of a setting and a function to update it
+ * Returns the value of a setting and a function to update it.
+ * @param path - The path of the settings file.
+ * @param key - The key of the setting.
+ * @param defaultValue - The default value of the setting.
+ * @param parse - A function that converts a string to a value.
+ * @param stringify - A function that converts a value to a string.
+ * @returns The value of a setting and a function to update it.
  */
 export declare function useSetting<Type = string>(path: SettingsPath, key: string, defaultValue: Type, parse: (value: string) => Type, stringify?: (value: Type) => string): [Type, (value: Type | string) => void];
 
 export declare function useSettingsManager(): SettingsManagerState;
 
 /**
- * Creates listeners for keyboard shortcuts
+ * A hook that initializes and manages a Shell instance within a React component.
+ * It gathers required system contexts and returns a reactive snapshot of the shell's state.
+ * @param config - Configuration subset required to instantiate the shell.
+ * @returns A tuple containing the stable {@link Shell} instance and its reactive {@link ShellState} snapshot.
+ * @example
+ * const sizeRef = useRef(Vector2.ZERO);
+ * const [shell, state] = useShell({
+ *		app: myApp,
+ *		path: "~",
+ *		input: "echo \"Hello world!\"",
+ *		exit: () => closeWindow(),
+ *		sizeRef,
+ *	});
  */
-export declare function useShortcuts({ options, shortcuts, useCategories }: UseShortcutsParams): void;
+export declare function useShell({ app, path, input, exit, sizeRef, }: Pick<ShellConfig, "app" | "path" | "input" | "exit" | "sizeRef">): [Shell, Snapshot<ShellState>];
 
-export declare interface UseShortcutsParams {
-    options: Record<string, Record<string, (event: KeyboardEvent) => void>> | Record<string, (event: KeyboardEvent) => void>;
-    shortcuts?: Record<string, Record<string, string[]>> | Record<string, string[]>;
-    useCategories?: boolean;
-}
+/**
+ * Creates listeners for keyboard shortcuts.
+ */
+export declare function useShortcuts(params: UseShortcutsParams): void;
+
+export declare type UseShortcutsParams = {
+    useCategories: true;
+    options: CategorizedOptions;
+    shortcuts?: CategorizedShortcuts;
+} | {
+    useCategories?: false;
+    options: FlatOptions;
+    shortcuts?: FlatShortcuts;
+};
 
 /**
- * Generates static class name using BEM notation
+ * Returns a stable value that is instantiated only once.
+ * Useful for classes or objects that should not be re-created on every render.
+ * @param create - A factory function that returns the singleton instance.
+ * @example
+ * const systemManager = useSingleton(() => new SystemManager(systemManagerParams));
+ */
+export declare function useSingleton<T>(create: () => T): T;
+
+export declare function useSkin(): Skin;
+
+/**
+ * Generates static class name using BEM notation.
+ * @param block - The name of the block.
+ * @param element - The name of the element.
+ * @param modifier - The name of the modifier(s).
  */
 export declare function useStaticClassName(block?: string, element?: string, modifier?: string | string[]): string | null;
 
+export declare function useStorage(): Storage_2;
+
 /**
- * Returns the value of a setting and a function to update it
- * @param path The path of the settings file
- * @param key The key of the setting
- * @param defaultValue The default value of the setting
- * @returns The value of a setting and a function to update it
+ * Returns the value of a setting and a function to update it.
+ * @param path - The path of the settings file.
+ * @param key - The key of the setting.
+ * @param defaultValue - The default value of the setting.
+ * @returns The value of a setting and a function to update it.
  */
 export declare function useStringSetting(path: SettingsPath, key: string, defaultValue?: string | null): [string | null, (value: string | null) => void];
 
@@ -1214,52 +1748,34 @@ export declare interface UseZIndexParams {
 
 export { utilStyles }
 
-export declare class Vector2 {
-    x: number;
-    y: number;
-    static get ZERO(): Vector2;
-    get clone(): Vector2;
-    constructor(x: number, y?: number);
-    round(): Vector2;
-    getDistance(x: number, y?: number): number;
-    getDistance(vector2: Vector2): number;
-    static add(vector2A: Vector2, vector2B: Vector2): Vector2;
-    static subtract(vector2A: Vector2, vector2B: Vector2): Vector2;
-    static scale(vector2: Vector2, scalar: number): Vector2;
-    static magnitude(vector2: Vector2): number;
-    static normalize(vector2: Vector2): Vector2;
-    static sqrDistance(vector2A: Vector2, vector2B: Vector2): number;
-    static lerp(vector2A: Vector2, vector2B: Vector2, t: number): Vector2;
-}
+export { Vector2 }
 
 export declare const VIDEO_EXTENSIONS: string[];
 
-declare class VirtualBase extends EventEmitter<EventNamesMap> {
-    /** The name of this item */
+export declare class VirtualBase<E extends VirtualBaseEvents = VirtualBaseEvents> extends EventEmitter<E & Record<keyof E, unknown[]>> {
+    /** The name of this item. */
     name: string;
-    /** The alias of this item */
+    /** The alias of this item. */
     alias: string | undefined | null;
-    /** The folder this item is in */
+    /** The folder this item is in. */
     parent: VirtualFolder | undefined | null;
-    /** Whether this item is protected from changes */
+    /** Whether this item is protected from changes. */
     isProtected: boolean | undefined | null;
-    /** The URL of the icon of this item */
+    /** The URL of the icon of this item. */
     iconUrl: string | undefined | null;
-    /** The file this item links to */
+    /** The file this item links to. */
     linkedFile: VirtualFile | undefined | null;
-    /** The folder this item links to */
+    /** The folder this item links to. */
     linkedFolder: VirtualFolder | undefined | null;
-    /** Whether this item has been edited by the user */
+    /** Whether this item has been edited by the user. */
     editedByUser: boolean | undefined | null;
-    /** Whether this item is the root folder */
+    /** Whether this item is the root folder. */
     isRoot: boolean | undefined | null;
-    /** The root folder */
+    /** The root folder. */
     root: VirtualRoot | undefined | null;
-    /** Whether this item has been deleted */
+    /** Whether this item has been deleted. */
     isDeleted: boolean;
-    static EVENT_NAMES: {
-        update: string;
-    };
+    static readonly UPDATE_EVENT = "update";
     constructor(name: string);
     get id(): string;
     setName(name: string): this;
@@ -1270,41 +1786,45 @@ declare class VirtualBase extends EventEmitter<EventNamesMap> {
     getIconUrl(): string;
     getType(): string;
     /**
-     * Tries to delete this item
+     * Tries to delete this item.
      */
     delete(): void;
     confirmChanges(root?: VirtualRoot): void;
     /**
-     * Opens this item in the appropriate application
+     * Opens this item in the appropriate application.
      */
     open(..._args: unknown[]): unknown;
     /**
-     * Returns the path of this item
+     * Returns the path of this item.
      */
     get path(): string;
     /**
-     * Returns path without using this item's alias
+     * Returns path without using this item's alias.
      */
     get displayPath(): string;
     /**
-     * Returns path without using any aliases
+     * Returns path without using any aliases.
      */
     get absolutePath(): string;
     /**
-     * Returns whether this can be edited in its current state
+     * Returns whether this can be edited in its current state.
      */
     get canBeEdited(): boolean;
     /**
-     * Returns the root folder
+     * Returns the root folder.
      */
     getRoot(): VirtualRoot;
-    isFile(): boolean;
-    isFolder(): boolean;
+    isFile(): this is VirtualFile;
+    isFolder(): this is VirtualFolder;
     toJSON(): VirtualBaseJson | null;
     toString(): string | null;
 }
 
-declare interface VirtualBaseJson {
+export declare interface VirtualBaseEvents {
+    update: [];
+}
+
+export declare interface VirtualBaseJson {
     nam: string;
     ico?: string;
 }
@@ -1317,36 +1837,55 @@ export declare class VirtualDriveConfig {
 
 export declare interface VirtualDriveConfigOptions {
     /**
-     * Enables persistent storage of the virtual drive
-     * @default true
+     * Enables persistent storage of the virtual drive.
+     * @default {
+     enableCompression: true,
+     prefix: "pos-"
+     }
      */
-    saveData: boolean;
+    saveData: false | {
+        /**
+         * Enables compression of stored items.
+         * @default false
+         */
+        enableCompression: boolean;
+        /**
+         * The prefix to prepend to stored keys.
+         * @default "pos-"
+         */
+        prefix?: string;
+        /**
+         * An array of tuples of old and new keys to migrate.
+         * @default [["data", VirtualDriveStorage.KEY]]
+         */
+        migrations?: [string, string][];
+    };
     /**
-     * Configure the data that is loaded initially when ProzillaOS is opened
+     * Configure the data that is loaded initially when ProzillaOS is opened.
      */
     defaultData: {
         /**
-         * Include pictures folder in default data
+         * Include pictures folder in default data.
          * @default true
          */
         includePicturesFolder?: boolean;
         /**
-         * Include documents folder in default data
+         * Include documents folder in default data.
          * @default true
          */
         includeDocumentsFolder?: boolean;
         /**
-         * Include desktop folder in default data
+         * Include desktop folder in default data.
          * @default true
          */
         includeDesktopFolder?: boolean;
         /**
-         * Include source tree folder in default data
+         * Include source tree folder in default data.
          * @default true
          */
         includeSourceTree?: boolean;
         /**
-         * Include apps folder in default data
+         * Include apps folder in default data.
          * @default true
          */
         includeAppsFolder?: boolean;
@@ -1354,29 +1893,35 @@ export declare interface VirtualDriveConfigOptions {
     };
 }
 
+export declare class VirtualDriveStorage extends Storage_2 {
+    virtualDriveConfig: VirtualDriveConfig;
+    static readonly KEY = "drive";
+    constructor(virtualDriveConfig: VirtualDriveConfig);
+    load(key: string): string | null;
+    store(key: string, value: string): void;
+    synchronize(): void;
+}
+
 /**
- * A virtual file that can be stored inside a folder
+ * A virtual file that can be stored inside a folder.
  */
-export declare class VirtualFile extends VirtualBase {
-    /** The extension of this file */
+export declare class VirtualFile extends VirtualBase<VirtualFileEvents> {
+    /** The extension of this file. */
     extension: OptionalStringProperty;
-    /** The URL of the source of this file */
+    /** The URL of the source of this file. */
     source: OptionalStringProperty;
-    /** The content of this file */
+    /** The content of this file. */
     content: OptionalStringProperty;
     static NON_TEXT_EXTENSIONS: string[];
-    static EVENT_NAMES: {
-        update: string;
-        contentChange: string;
-    };
+    static readonly CONTENT_CHANGE_EVENT = "contentChange";
     constructor(name: string, extension?: string);
     setAlias(alias: string): this;
     /**
-     * Sets the source of this file and removes the content
+     * Sets the source of this file and removes the content.
      */
     setSource(source: string): this;
     /**
-     * Sets the content of this file and removes the source
+     * Sets the content of this file and removes the source.
      */
     setContent(content: string | string[]): this;
     get id(): string;
@@ -1385,11 +1930,11 @@ export declare class VirtualFile extends VirtualBase {
         extension: OptionalStringProperty;
     };
     /**
-     * Opens this file in an app associated with its extension
+     * Opens this file in an app associated with its extension.
      */
     open(windowsManager: WindowsManager): object | null;
     read(): Promise<OptionalStringProperty | undefined>;
-    isFile(): boolean;
+    isFile(): this is VirtualFile;
     getIconUrl(): string;
     getType(): string;
     download(): void;
@@ -1398,6 +1943,10 @@ export declare class VirtualFile extends VirtualBase {
     static removeFileScheme(source: string): string;
 }
 
+export declare interface VirtualFileEvents extends VirtualBaseEvents {
+    contentChange: [VirtualFile];
+}
+
 export declare interface VirtualFileJson extends VirtualBaseJson {
     ext?: string;
     cnt?: string;
@@ -1405,12 +1954,12 @@ export declare interface VirtualFileJson extends VirtualBaseJson {
 }
 
 /**
- * A link that points to a virtual file
+ * A link that points to a virtual file.
  */
 export declare class VirtualFileLink extends VirtualFile {
     linkedPath?: string;
     constructor(name: string, linkedFile?: VirtualFile);
-    setLinkedFile(file: VirtualFile): VirtualFileLink;
+    setLinkedFile(file: VirtualFile | null): VirtualFileLink;
     setLinkedPath(path: string): VirtualFileLink;
     isValid(): boolean;
     toJSON(): VirtualFileLinkJson | null;
@@ -1428,15 +1977,15 @@ export declare interface VirtualFileLinkJson extends VirtualFileJson {
 }
 
 /**
- * A virtual folder that can contains files and sub-folders
+ * A virtual folder that can contains files and sub-folders.
  */
-export declare class VirtualFolder extends VirtualBase {
-    /** The folders inside this folder */
+export declare class VirtualFolder<E extends VirtualBaseEvents = VirtualBaseEvents> extends VirtualBase<E> {
+    /** The folders inside this folder. */
     subFolders: (VirtualFolder | VirtualFolderLink)[];
-    /** The files inside this folder */
+    /** The files inside this folder. */
     files: (VirtualFile | VirtualFileLink)[];
     /**
-     * The type of this folder
+     * The type of this folder.
      * @default VirtualFolder.TYPE.general
      */
     type: number | undefined;
@@ -1447,90 +1996,94 @@ export declare class VirtualFolder extends VirtualBase {
     constructor(name: string, type?: number);
     setAlias(alias: string): this;
     /**
-     * Returns true if this folder contains a file matching a name and extension
+     * Returns true if this folder contains a file matching a name and extension.
      */
     hasFile(name: string, extension?: string): boolean;
     /**
-     * Returns true if this folder contains a folder matching a name
+     * Returns true if this folder contains a folder matching a name.
      */
     hasFolder(name: string): boolean;
     /**
-     * Finds and returns a file inside this folder matching a name and extension
+     * Finds and returns a file inside this folder matching a name and extension.
      */
     findFile(name: string, extension?: string | null): VirtualFile | VirtualFileLink | null;
     /**
-     * Finds and returns a folder inside this folder matching a name
+     * Finds and returns a folder inside this folder matching a name.
      */
     findSubFolder(name: string): VirtualFolder | VirtualFolderLink | null;
+    addFile(file: VirtualFile, confirmChanges?: boolean): this;
     /**
-     * Creates a file with a name and extension
+     * Creates a file with a name and extension.
      */
     createFile(name: string, extension?: string, callback?: (newFile: VirtualFile | VirtualFileLink) => void): this;
     /**
-     * Creates files based on an array of objects with file names and extensions
+     * Creates files based on an array of objects with file names and extensions.
      */
     createFiles(files: {
         name: string;
         extension: string;
     }[]): this;
     /**
-     * Creates a file link with a name
+     * Creates a file link with a name.
      */
     createFileLink(name: string, callback?: (newFileLink: VirtualFileLink | VirtualFile) => void): this;
     /**
-     * Creates file links based on an array of objects with file names and extensions
+     * Creates file links based on an array of objects with file names and extensions.
      */
     createFileLinks(fileLinks: {
         name: string;
     }[]): this;
+    addFolder(folder: VirtualFolder, confirmChanges?: boolean): this;
     /**
-     * Creates a folder with a name
+     * Creates a folder with a name.
      */
     createFolder(name: string, callback?: (newFolder: VirtualFolder) => void): this;
     /**
-     * Creates folders based on an array of folder names
+     * Creates folders based on an array of folder names.
      */
     createFolders(names: string[]): this;
     /**
-     * Creates a folder link with a name
+     * Creates a folder link with a name.
      */
     createFolderLink(name: string, callback?: (newFolderLink: VirtualFolderLink | VirtualFolder) => void): this;
     /**
-     * Creates folder links based on an array of folder names
+     * Creates folder links based on an array of folder names.
      */
     createFolderLinks(names: string[]): this;
     /**
-     * Removes a file or folder from this folder
+     * Removes a file or folder from this folder.
      */
     remove(child: VirtualFile | VirtualFileLink | VirtualFolder | VirtualFolderLink): this;
     /**
-     * Returns the file or folder at a relative path or null if it doesn't exist
+     * Returns the file or folder at a relative path or null if it doesn't exist.
      */
     navigate(relativePath: string): VirtualFile | VirtualFolder | null;
+    navigateToFolder(relativePath: string): VirtualFolder | null;
+    navigateToFile(relativePath: string): VirtualFile | null;
     /**
-     * Opens this folder in file explorer
+     * Opens this folder in file explorer.
      */
     open(windowsManager: WindowsManager): object | null | undefined;
     /**
-     * Deletes this folder and all its files and sub-folders recursively
+     * Deletes this folder and all its files and sub-folders recursively.
      */
     delete(): void;
     /**
-     * Returns all files inside this folder
-     * @param showHidden Whether to include hidden files
+     * Returns all files inside this folder.
+     * @param showHidden - Whether to include hidden files.
      */
     getFiles(showHidden?: boolean): VirtualFile[];
     /**
-     * Returns all sub-folders inside this folder
-     * @param showHidden Whether to include hidden folders
+     * Returns all sub-folders inside this folder.
+     * @param showHidden - Whether to include hidden folders.
      */
     getSubFolders(showHidden?: boolean): VirtualFolder[];
     /**
-     * Returns the amount of files and sub-folders inside this folder
-     * @param includeHidden Whether to include hidden files and folders in the count
+     * Returns the amount of files and sub-folders inside this folder.
+     * @param includeHidden - Whether to include hidden files and folders in the count.
      */
     getItemCount(includeHidden?: boolean): number;
-    isFolder(): boolean;
+    isFolder(): this is VirtualFolder;
     getIconUrl(): string;
     toJSON(): VirtualFolderJson | null;
 }
@@ -1541,12 +2094,12 @@ export declare interface VirtualFolderJson extends VirtualBaseJson {
 }
 
 /**
- * A link that points to a virtual folder
+ * A link that points to a virtual folder.
  */
 export declare class VirtualFolderLink extends VirtualFolder {
     linkedPath?: string;
     constructor(name: string, linkedFolder?: VirtualFolder);
-    setLinkedFolder(folder: VirtualFolder): VirtualFolderLink;
+    setLinkedFolder(folder: VirtualFolder | null): VirtualFolderLink;
     setLinkedPath(path: string): VirtualFolderLink;
     isValid(): boolean;
     getIconUrl(): string;
@@ -1571,35 +2124,33 @@ export declare interface VirtualFolderLinkJson extends VirtualFolderJson {
 }
 
 /**
- * A virtual folder that serves as the root folder
+ * A virtual folder that serves as the root folder.
  */
-export declare class VirtualRoot extends VirtualFolder {
-    /** Aliases for files and folders */
+export declare class VirtualRoot extends VirtualFolder<VirtualRootEvents> {
+    /** Aliases for files and folders. */
     shortcuts: Record<string, VirtualFile | VirtualFileLink | VirtualFolder | VirtualFolderLink>;
     initiated: boolean;
     loadedDefaultData: boolean;
     systemManager: SystemManager;
-    static EVENT_NAMES: {
-        update: string;
-        error: string;
-    };
+    storage: VirtualDriveStorage;
+    static readonly ERROR_EVENT = "error";
     constructor(systemManager: SystemManager);
     loadDefaultData(): void;
     loadData(): void;
     /**
-     * Calls the storage manager's store function with this root's data as a string
+     * Calls the storage manager's store function with this root's data as a string.
      */
     saveData(): void;
     /**
-     * Initializes this root by loading the default data and then the user's data on top
+     * Initializes this root by loading the default data and then the user's data on top.
      */
     init(): VirtualRoot;
     /**
-     * Adds a shortcut to a file or folder
+     * Adds a shortcut to a file or folder.
      */
     addShortcut(name: string, destination: VirtualFile | VirtualFileLink | VirtualFolder | VirtualFolderLink): this;
     /**
-     * Tells the storage manager to clear all data and reloads the window
+     * Tells the storage manager to clear all data and reloads the window.
      */
     reset(): void;
     static isValidName(_name: string): boolean;
@@ -1613,6 +2164,12 @@ export declare class VirtualRoot extends VirtualFolder {
 
 export declare const VirtualRootContext: Context<VirtualRootState>;
 
+export declare interface VirtualRootEvents extends VirtualBaseEvents {
+    error: [{
+        message: string;
+    }];
+}
+
 export declare interface VirtualRootJson extends VirtualFolderJson {
     scs: Record<string, string>;
 }
@@ -1620,29 +2177,31 @@ export declare interface VirtualRootJson extends VirtualFolderJson {
 export declare type VirtualRootState = VirtualRoot | undefined;
 
 /**
- * Component that renders an external application inside an iframe
+ * Component that renders an external application inside an iframe.
  */
-export declare const WebView: FC<WebViewProps>;
+export declare const WebView: ForwardRefExoticComponent<Omit<WebViewProps, "ref"> & RefAttributes<HTMLIFrameElement>>;
 
 export declare interface WebViewProps extends WindowProps {
-    /** The URL of the external application */
+    /** The URL of the external application. */
     source?: string;
     title?: string;
 }
 
+export declare const WELCOME_MESSAGE: string;
+
 export declare function WindowedModal({ modal, params, children, ...props }: ModalProps): JSX_2.Element;
 
 export declare interface WindowOptions {
-    /** The ID of the window */
+    /** The ID of the window. */
     id?: string;
-    /** The app associated with the window */
+    /** The app associated with the window. */
     app?: App;
     /**
-     * The size of the window
+     * The size of the window.
      * @default new Vector2(700, 400)
      */
     size?: Vector2;
-    /** The position of the window */
+    /** The position of the window. */
     position?: Vector2;
     fullscreen?: boolean | string;
     options?: object;
@@ -1654,29 +2213,27 @@ export declare interface WindowOptions {
 
 export declare interface WindowProps extends WindowOptions {
     /**
-     * Whether to start the window in fullscreen mode
+     * Whether to start the window in fullscreen mode.
      * @default false
      */
     fullscreen?: boolean;
-    /** Function that handles interactions with the window */
-    onInteract?: () => void;
-    /** Function that sets the title of the window */
+    /** Function that sets the title of the window. */
     setTitle?: React.Dispatch<React.SetStateAction<string>>;
-    /** Function that sets the icon URL of the window */
+    /** Function that sets the icon URL of the window. */
     setIconUrl?: React.Dispatch<React.SetStateAction<string>>;
-    /** Function that closes the window */
-    close?: (event?: Event) => void;
-    /** Function that brings the window in focus */
-    focus?: (event: Event, force?: boolean) => void;
-    /** Whether the window is currently focused and should allow interactions */
+    /** Function that closes the window. */
+    close?: (event?: Event | React.UIEvent<HTMLElement>) => void;
+    /** Function that brings the window in focus. */
+    focus?: (event?: Event | React.UIEvent<HTMLElement>, force?: boolean) => void;
+    /** Whether the window is currently focused and should allow interactions. */
     active?: boolean;
-    /** Whether to start the window in minimized mode */
+    /** Whether to start the window in minimized mode. */
     minimized?: boolean;
-    /** Function that toggles the minimized mode of the window */
+    /** Function that toggles the minimized mode of the window. */
     toggleMinimized?: (event?: Event) => void;
-    /** The depth value of the window */
+    /** The depth value of the window. */
     index?: number;
-    /** Whether the window is in standalone mode */
+    /** Whether the window is in standalone mode. */
     standalone?: boolean;
 }
 
@@ -1689,75 +2246,76 @@ export declare class WindowsConfig {
 
 export declare interface WindowsConfigOptions {
     /**
-     * The margin around windows that are not maximized, in pixels
+     * The margin around windows that are not maximized, in pixels.
      * @default 32
      */
     screenMargin: number;
     /**
-     * The separator to use in window titles
+     * The separator to use in window titles.
      * @default "-"
      */
     titleSeparator: string;
     /**
-     * If the user's screen is smaller than these values, windows will always be maximized
+     * If the user's screen is smaller than these values, windows will always be maximized.
      * @default new Vector2(350, 350)
      */
     minScreenSize: Vector2;
 }
 
 /**
- * Manages the states of windows
+ * Manages the states of windows.
  */
 export declare class WindowsManager {
     #private;
     windows: {
         [id: string]: WindowOptions;
     };
-    /** Function that handles changes to the open windows */
+    /** Function that handles changes to the open windows. */
     updateWindows: (window: WindowsManager["windows"]) => void;
     startupComplete: boolean;
     constructor(systemManager: SystemManager, trackingManager: TrackingManager);
     /**
-     * Opens a window for an application
-     * @param appId The ID of the app
+     * Opens a window for an application.
+     * @param appId - The ID of the app.
      */
     open(appId: string, options?: WindowOptions | null): object | null;
     /**
-     * Opens a file with the associated app or by a method specified by the file scheme
-     * @returns Opened window
+     * Opens a file with the associated app or by a method specified by the file scheme.
+     * @returns Opened window.
      */
     openFile(file: VirtualFile, options?: object): object | null;
     /**
-     * Close a window
+     * Close a window.
      */
     close(windowId: string): void;
     /**
-     * Focus on a specific window
+     * Focus on a specific window.
      */
     focus(windowId: string): void;
     /**
-     * Check whether a window is focused
+     * Check whether a window is focused.
      */
     isFocused(windowId: string): boolean | undefined;
     /**
-     * Check if any window is focused
+     * Check if any window is focused.
      */
     isAnyFocused(): boolean;
     /**
-     * Change the minimized state of a window
-     * @param minimized - Leave as undefined to toggle the window's minimization state
+     * Change the minimized state of a window.
+     * @param windowId - The ID of the window.
+     * @param minimized - Leave as undefined to toggle the window's minimization state.
      */
     setMinimized(windowId: string, minimized?: boolean): void;
     /**
-     * Minimize all windows
+     * Minimize all windows.
      */
     minimizeAll(): void;
     /**
-     * Check if an app has an open window
+     * Check if an app has an open window.
      */
     isAppActive(appId: string): boolean;
     /**
-     * Get an opened window of a certain app
+     * Get an opened window of a certain app.
      */
     getAppWindowId(appId: string): string | null;
     setUpdateWindows(updateWindows: WindowsManager["updateWindows"]): void;
@@ -1770,17 +2328,17 @@ export declare const WindowsManagerContext: Context<WindowsManagerState>;
 export declare type WindowsManagerState = WindowsManager | undefined;
 
 /**
- * Component that renders the windows for all currently active applications
+ * Component that renders the windows for all currently active applications.
  */
 export declare const WindowsView: FC;
 
 /**
- * Component that renders the window for an application
+ * Component that renders the window for an application.
  */
 export declare const WindowView: FC<WindowProps>;
 
 /**
- * Represents a group of HTML elements whose z-index is automatically calculated based on a given order
+ * Represents a group of HTML elements whose z-index is automatically calculated based on a given order.
  */
 export declare class ZIndexGroup {
     length: number;
@@ -1794,23 +2352,21 @@ export declare class ZIndexGroup {
     getIndex(index: number): number;
 }
 
-export declare class ZIndexManager extends EventEmitter<typeof ZIndexManagerEvents> {
+export declare class ZIndexManager extends EventEmitter<ZIndexManagerEvents> {
     static GROUPS: {
         WINDOWS: number;
         TASKBAR: number;
         MODALS: number;
     };
-    static EVENT_NAMES: {
-        readonly indexChange: "indexChange";
-    };
+    static readonly INDEX_CHANGE_EVENT = "indexChange";
     groups: ZIndexGroup[];
     constructor();
     update(): void;
     getIndex(groupIndex: number, index: number): number;
 }
 
-declare const ZIndexManagerEvents: {
-    readonly indexChange: "indexChange";
-};
+export declare interface ZIndexManagerEvents {
+    indexChange: [];
+}
 
 export { }