@prozilla-os/core 1.3.11 → 1.3.13

package/dist/main.d.ts

@@ -1,3 +1,4 @@
+import { Context } from 'react';
 import { FC } from 'react';
 import { HTMLAttributeAnchorTarget } from 'react';
 import { IconProp } from '@fortawesome/fontawesome-svg-core';
@@ -12,17 +13,24 @@ import { Ref } from 'react';
 import { UaEventOptions } from 'react-ga4/types/ga4';
 import { default as utilStyles } from './utils.module.css';
 
-declare interface ActionProps {
+export declare interface ActionProps {
+    /** ID of the action */
     actionId?: string;
+    /** Label of the action */
     label?: string;
+    /** Icon for the action */
     icon?: string | object;
+    /** Keyboard shortcut for the action */
     shortcut?: string[];
+    /** 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 */
     disabled?: boolean;
 }
 
 /**
+ * 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"
@@ -35,20 +43,34 @@ declare interface ActionProps {
  */
 export declare function Actions({ children, mode, className, onAnyTrigger, triggerParams, avoidTaskbar }: ActionsProps): ReactElement;
 
-declare interface ActionsProps {
+export declare interface ActionsProps {
     mode?: string;
+    /** `className` prop for the container */
     className?: string;
+    /** 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 */
     triggerParams?: unknown;
+    /** Whether the actions should automatically orient themselves to not overlap with the taskbar */
     avoidTaskbar?: boolean;
     [key: string]: unknown;
 }
 
-declare interface AlertParams {
+export declare interface AlertParams {
+    /**
+     * The title of the alert
+     * @default "Alert"
+     */
     title: string;
+    /** The body of the alert */
     text: string;
+    /** The URL of the icon of the alert */
     iconUrl?: string;
+    /**
+     * The size of the alert modal
+     * @default new Vector2(300, 150)
+     */
     size?: Vector2;
     single?: boolean;
 }
@@ -71,9 +93,9 @@ export declare class App<AppProps extends WindowProps = WindowProps> {
      */
     windowContent: FC<AppProps>;
     /**
-     * Default options that get passed to the {@link this.windowContent} component
+     * Default options that get passed to the {@link App.windowContent} component
      */
-    windowOptions?: Partial<AppProps> & WindowOptions_2;
+    windowOptions?: Partial<AppProps> & DefaultWindowOptions;
     /**
      * Description of this application
      */
@@ -116,26 +138,29 @@ export declare class App<AppProps extends WindowProps = WindowProps> {
     isActive: boolean;
     isPinned?: boolean;
     isInstalled: boolean;
-    constructor(name: App["name"], id: App["id"], windowContent: App<AppProps>["windowContent"], windowOptions?: Partial<AppProps> & WindowOptions_2);
+    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
+     */
     WindowContent: (props: AppProps) => JSX_2.Element | null;
     /**
-     * Set the display name of this application
+     * Sets the display name of this application
      */
     setName(name: string): this;
     /**
-     * Set the description of this application
+     * Sets the description of this application
      */
     setDescription(description: App["description"]): this;
     /**
-     * Set the URL of the icon of this application
+     * Sets the URL of the icon of this application
      */
     setIconUrl(iconUrl: App["iconUrl"]): this;
     /**
-     * Set the role of this application
+     * Sets the role of this application
      */
     setRole(role: string | null): this;
     /**
-     * Set the associated extensions of this application
+     * Sets the associated extensions of this application
      */
     setAssociatedExtensions(extensions: string[] | null): this;
     /**
@@ -151,11 +176,11 @@ export declare class App<AppProps extends WindowProps = WindowProps> {
      */
     setInstalled(installed: boolean): this;
     /**
-     * Changes the category this application belongs to
+     * Sets the category this application belongs to
      */
     setCategory(category: typeof APP_CATEGORIES[number] | null): this;
     /**
-     * Changes the metadata for this application
+     * Sets the metadata for this application
      */
     setMetadata(metadata: AppMetadata | null): this;
     /**
@@ -163,14 +188,14 @@ export declare class App<AppProps extends WindowProps = WindowProps> {
      */
     setShowDesktopIcon(showDesktopIcon: boolean): this;
     /**
-     * Changes the default options for the {@link this.windowContent} component
+     * Sets the default options for the {@link App.windowContent} component
      */
-    setWindowOptions(windowOptions: Partial<AppProps> & WindowOptions_2): this;
+    setWindowOptions(windowOptions: Partial<AppProps> & DefaultWindowOptions): this;
 }
 
 export declare const APP_CATEGORIES: readonly ["Business", "Developer tools", "Education", "Entertainment", "Food & dining", "Health & fitness", "Kids & family", "Lifestyle", "Media", "Medical", "Multimedia design", "Music", "Navigation & maps", "News & weather", "Personal finance", "Personalization", "Photo & video", "Productivity", "Security", "Shopping", "Social", "Sports", "Travel", "Utilities & tools"];
 
-declare interface AppMetadata {
+export declare interface AppMetadata {
     name: string;
     version: `${number}.${number}.${number}`;
     author: string;
@@ -206,16 +231,18 @@ export declare class AppsConfig {
     getAppsByCategory(category: typeof APP_CATEGORIES[number]): App[];
 }
 
-declare interface AppsConfigOptions {
+export declare interface AppsConfigOptions {
     /**
      * An array of applications
      */
     apps: App<WindowProps>[];
 }
 
+export declare const AUDIO_EXTENSIONS: string[];
+
 export declare function Button({ className, href, children, icon, target, ...props }: ButtonProps): JSX_2.Element;
 
-declare interface ButtonProps {
+export declare interface ButtonProps {
     className?: string;
     href?: string;
     icon?: IconProp;
@@ -226,7 +253,7 @@ declare interface ButtonProps {
 
 export declare const ClickAction: MemoExoticComponent<({ actionId, label, shortcut, disabled, onTrigger, icon }: ClickActionProps) => JSX_2.Element>;
 
-declare interface ClickActionProps extends ActionProps {
+export declare interface ClickActionProps extends ActionProps {
     icon?: string | object;
 }
 
@@ -242,6 +269,14 @@ export declare function copyToClipboard(string: string, onSuccess?: (value: void
 
 export declare function DefaultRoute(): JSX_2.Element;
 
+export declare interface DefaultWindowOptions {
+    size?: Vector2;
+    [key: string]: unknown;
+}
+
+/**
+ * Component that renders the wallpaper and desktop icons
+ */
 export declare const Desktop: MemoExoticComponent<() => JSX_2.Element>;
 
 export declare class DesktopConfig {
@@ -250,12 +285,14 @@ export declare class DesktopConfig {
     constructor(options?: Partial<DesktopConfigOptions>);
 }
 
-declare interface DesktopConfigOptions {
+export declare interface DesktopConfigOptions {
     /**
+     * The default size of the icons
      * @default 1
      */
     defaultIconSize: 0 | 1 | 2;
     /**
+     * The defailt direction of the icons
      * 0: vertical, 1: horizontal
      * @default 0
      * */
@@ -264,36 +301,58 @@ declare interface DesktopConfigOptions {
 
 export declare function DialogBox({ modal, params, children, ...props }: ModalProps): JSX_2.Element;
 
+/**
+ * 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;
 
-declare interface DirectoryListProps {
+export declare interface DirectoryListProps {
+    /** The directory to display */
     directory: VirtualFolder;
+    /** Whether to show hidden files and folders */
     showHidden?: boolean;
+    /** `className` prop for folders */
     folderClassName?: string;
+    /** `className` prop for files */
     fileClassName?: string;
+    /** `className` prop for this component */
     className?: string;
+    /** Function that handles context menu interactions on files */
     onContextMenuFile?: FileEventHandler;
+    /** Function that handles context menu interactions on folders */
     onContextMenuFolder?: FolderEventHandler;
+    /** Function that handles file opening events */
     onOpenFile?: FileEventHandler;
+    /** Function that handles folder opening events */
     onOpenFolder?: FolderEventHandler;
+    /** Whether to allow multiple files and folders to be selected at the same time */
     allowMultiSelect?: boolean;
+    /** Function that handles selection changes */
     onSelectionChange?: (params: OnSelectionChangeParams) => void;
     [key: string]: unknown;
 }
 
 export declare function Divider(): JSX_2.Element;
 
+export declare function downloadUrl(url: string, name: string): void;
+
 export declare function DropdownAction({ label, icon, children, showOnHover }: DropdownActionProps): ReactElement;
 
-declare interface DropdownActionProps extends ActionProps {
+export declare interface DropdownActionProps extends ActionProps {
     showOnHover?: boolean;
 }
 
+/**
+ * Component that opens a dropdown menu
+ */
 export declare function DropdownButton({ label, options, shortcuts }: DropdownButtonProps): JSX_2.Element;
 
-declare interface DropdownButtonProps {
+export declare interface DropdownButtonProps {
+    /** 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 */
     shortcuts: Record<string, string[]>;
 }
 
@@ -303,11 +362,11 @@ declare class EventEmitter<EventMap extends EventNamesMap> {
     /**
      * Add event listener for an event
      */
-    on<Key extends keyof EventMap>(eventName: Key, callback: (data: unknown) => void): void;
+    on<Key extends keyof EventMap>(eventName: Key, callback: Listener): Listener;
     /**
      * Remove event listener for an event
      */
-    off<Key extends keyof EventMap>(eventName: Key, callback: (data: unknown) => void): void;
+    off<Key extends keyof EventMap>(eventName: Key, callback: Listener): void;
     /**
      * Dispatch event
      */
@@ -332,9 +391,9 @@ export declare type FolderEventHandler = (event: Event, folder: VirtualFolder) =
  */
 export declare function formatShortcut(shortcut: string[]): string;
 
-export declare function generateUrl(options: GenerateUrlOptions): string;
+export declare function generateUrl(options: GenerateUrlParams): string;
 
-declare interface GenerateUrlOptions {
+export declare interface GenerateUrlParams {
     appId?: string;
     fullscreen?: boolean;
     standalone?: boolean;
@@ -342,6 +401,9 @@ declare interface GenerateUrlOptions {
 
 export declare function getViewportParams(): Record<string, string>;
 
+/**
+ * Component that shows a header menu at the top of a window
+ */
 export declare function HeaderMenu({ children, ...props }: ActionsProps): JSX_2.Element;
 
 declare function Image_2({ className, src, ...props }: ImageProps): JSX_2.Element;
@@ -351,22 +413,27 @@ export declare const IMAGE_EXTENSIONS: string[];
 
 export declare function ImagePreview({ source, className, onError, ...props }: ImagePreviewProps): JSX_2.Element;
 
-declare interface ImagePreviewProps {
+export declare interface ImagePreviewProps {
     source: string;
     className?: string;
     onError?: () => void;
 }
 
-declare interface ImageProps {
+export declare interface ImageProps {
     className?: string;
     src?: string;
     [key: string]: unknown;
 }
 
+/**
+ * Button component that handles single and double clicks
+ */
 export declare function Interactable({ onClick, onDoubleClick, children, ...props }: InteractableProps): JSX_2.Element;
 
-declare interface InteractableProps {
+export declare interface InteractableProps {
+    /** Function that handles single clicks */
     onClick?: (event: MouseEvent) => void;
+    /** Function that handles double clicks */
     onDoubleClick?: (event: MouseEvent) => void;
     children: ReactNode;
     [key: string]: unknown;
@@ -374,12 +441,16 @@ declare interface InteractableProps {
 
 export declare function isValidUrl(string: string): boolean;
 
+declare type Listener = (data: unknown) => void;
+
+export declare const MEDIA_EXTENSIONS: string[];
+
 export declare class MiscConfig {
     doubleClickDelay: MiscConfigOptions["doubleClickDelay"];
     constructor(options?: Partial<MiscConfigOptions>);
 }
 
-declare interface MiscConfigOptions {
+export declare interface MiscConfigOptions {
     /**
      * The maximum time between two clicks to register as a double click (in ms)
      * @default 250
@@ -387,17 +458,49 @@ declare interface MiscConfigOptions {
     doubleClickDelay: number;
 }
 
-declare class Modal {
+/**
+ * Represents a modal window
+ */
+export declare class Modal {
+    /**
+     * The size of this modal
+     * @default new Vector2(400, 200)
+     */
     size: Vector2;
+    /**
+     * The position of this modal
+     * @default new Vector2(300, 300)
+     */
     position: Vector2;
+    /**
+     * The icon of this modal
+     * @default null
+     */
     icon: string | null;
+    /**
+     * The title of this modal
+     * @default null
+     */
     title: string | null;
+    /**
+     * The manager that handles all modals
+     */
     modalsManager: ModalsManager | null;
+    /**
+     * The content of this modal
+     * @default null
+     */
     element: FC<ModalProps> | null;
     props: object;
     callback: ((...args: unknown[]) => void) | null;
+    /** The ID of this modal */
     id: number | null;
+    /**
+     * Whether this modal can be dismissed (e.g., by pressing ESC)
+     * @default true
+     */
     dismissible: boolean;
+    /** Timestamp of the most recent interaction with this modal */
     lastInteraction?: number;
     constructor(element: Modal["element"], callback?: Modal["callback"]);
     setIcon(icon: string): Modal;
@@ -416,6 +519,7 @@ declare class Modal {
 }
 
 export declare interface ModalProps {
+    /**  */
     modal?: Modal;
     params?: {
         appId?: string;
@@ -439,7 +543,7 @@ export declare class ModalsConfig {
     constructor(options?: Partial<ModalsConfigOptions>);
 }
 
-declare interface ModalsConfigOptions {
+export declare interface ModalsConfigOptions {
     /**
      * Default size of a dialog box
      * @default new Vector2(400, 200)
@@ -452,71 +556,126 @@ declare interface ModalsConfigOptions {
     defaultFileSelectorSize: Vector2;
 }
 
+/**
+ * Manages the opening, closing and ordering of modals
+ */
 export declare class ModalsManager {
+    /** Maps every modal ID to the corresponding modal */
     modals: Record<string, Modal>;
     containerRef?: MutableRefObject<HTMLElement>;
+    /** Function that handles changes to modals */
     updateModals: (modals: ModalsManager["modals"]) => void;
     /**
+     * Opens a modal
      * @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
+     */
     close(modalId: string | number, sendModalsUpdate?: boolean): void;
+    /**
+     * 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
+     */
     get modalIds(): string[];
     static getModalIconUrl(name: string): string;
 }
 
-declare type ModalsManagerState = ModalsManager | undefined;
+export declare const modalsManagerContext: Context<ModalsManagerState>;
 
+export declare type ModalsManagerState = ModalsManager | undefined;
+
+/**
+ * Component that renders all active modals
+ */
 export declare const ModalsView: MemoExoticComponent<() => JSX_2.Element>;
 
 export declare function NoRoute(): JSX_2.Element;
 
+export declare interface NoRouteProps {
+    /**
+     * Title of the route
+     * @default "404: Not Found"
+     */
+    title: string;
+}
+
 export declare interface OnSelectionChangeParams {
+    /** The selected files */
     files?: string[];
+    /** The selected folders */
     folders?: string[];
+    /** The directory the selection was made in */
     directory?: VirtualFolder;
 }
 
 export declare function openUrl(url: string, target?: HTMLAttributeAnchorTarget): void;
 
-declare type OpenWindowedModal = (params: OpenWindowedModalParams) => Modal;
+export declare type OpenWindowedModal = (params: OpenWindowedModalParams) => Modal;
 
-declare interface OpenWindowedModalParams {
+export declare interface OpenWindowedModalParams {
+    /** The ID of the associated app */
     appId?: string;
+    /** The URL of the icon of the modal */
     iconUrl?: string;
+    /** The title of the modal */
     title?: string;
+    /** The size of the modal */
     size: Vector2;
+    /** The modal component */
     Modal: FC<ModalProps>;
     single?: boolean;
     fullscreen?: WindowProps["fullscreen"];
 }
 
-declare type OptionalStringProperty = string | null | undefined;
+export declare type OptionalStringProperty = string | null | undefined;
 
+/**
+ * Component that calls a function when the user clicks outside of it
+ */
 export declare const OutsideClickListener: MemoExoticComponent<({ onOutsideClick, children }: OutsideClickListenerProps) => JSX_2.Element>;
 
-declare interface OutsideClickListenerProps {
+export declare interface OutsideClickListenerProps {
+    /** Function that handles clicks outside of this component */
     onOutsideClick: (event: Event) => void;
     children: ReactNode;
 }
 
+/**
+ * Component that renders a progress bar
+ */
 export declare function ProgressBar({ fillPercentage, fillColor, backgroundColor, align, className }: ProgressBarProps): JSX_2.Element;
 
-declare interface ProgressBarProps {
+export declare interface ProgressBarProps {
+    /** The amount of progress, as a percentage */
     fillPercentage: number;
+    /** The CSS color to use for the filled part of the progress bar */
     fillColor?: string;
+    /** The CSS background color of the progress bar */
     backgroundColor?: string;
     align?: "left";
+    /** `className` prop for the progress bar */
     className?: string;
 }
 
+/**
+ * Main component that contains everything
+ */
 export declare const ProzillaOS: NamedExoticComponent<ProzillaOSProps>;
 
-declare interface ProzillaOSProps {
+export declare interface ProzillaOSProps {
+    /** The name of the system */
     systemName?: string;
+    /** The tagline/short description of the system */
     tagLine?: string;
+    /** The system configuration */
     config?: {
         apps?: Partial<AppsConfigOptions>;
         desktop?: Partial<DesktopConfigOptions>;
@@ -543,7 +702,7 @@ export declare function RadioAction({ actionId, options, initialIndex, onTrigger
  * @param {number} props.initialIndex
  * @param {Function} props.onTrigger
  */
-declare interface RadioActionProps extends ActionProps {
+export declare interface RadioActionProps extends ActionProps {
     options: {
         label: string;
         shortcut?: string[];
@@ -562,14 +721,14 @@ export declare function removeUrlProtocol(url: string): string;
 
 export declare function Router({ path, homePage, fallbackPage, children }: RouterProps): JSX_2.Element;
 
-declare interface RouterProps {
+export declare interface RouterProps {
     path?: string;
     homePage?: JSX.Element;
     fallbackPage?: JSX.Element;
     children?: ReactElement;
 }
 
-declare class Settings {
+export declare class Settings {
     #private;
     path: string;
     file: VirtualFile;
@@ -585,10 +744,39 @@ declare class Settings {
      */
     isMissingXmlDoc(): Promise<boolean>;
     /**
-     * Gets a value by a given key if it exists or calls a callback function 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;
+    }>;
+    /**
+     * Gets a value by a given key as a boolean
+     */
+    getBool(key: string, callback?: (value: boolean) => void): Promise<{
+        value: boolean | null;
+        listener?: Listener;
+    }>;
+    /**
+     * Gets a value by a given key as an integer
+     */
+    getInt(key: string, callback?: (value: number) => void): Promise<{
+        value: number | null;
+        listener?: Listener;
+    }>;
+    /**
+     * Sets the value associated with a given key
+     * @param key The key of the setting
+     * @param value The new value
      */
-    get(key: string, callback?: (value: string) => void): Promise<string | null>;
     set(key: string, value: string): Promise<void>;
+    /**
+     * Removes a listener from the settings file
+     * @param listener The listener to remove
+     */
+    removeListener(listener: Listener): void;
 }
 
 export declare class SettingsManager {
@@ -600,7 +788,11 @@ export declare class SettingsManager {
     getSettings(path: string): Settings;
 }
 
-declare type SettingsManagerState = SettingsManager | undefined;
+export declare const SettingsManagerContext: Context<SettingsManagerState>;
+
+export declare type SettingsManagerState = SettingsManager | undefined;
+
+export declare type SettingsPath = typeof SettingsManager.VIRTUAL_PATHS[string];
 
 export declare function setViewportIcon(url: string): void;
 
@@ -659,6 +851,8 @@ declare interface SkinOptions {
         text?: string;
         code?: string;
         external?: string;
+        video?: string;
+        audio?: string;
     };
     /**
      * URLs of icons for types of folders
@@ -668,6 +862,8 @@ declare interface SkinOptions {
         images?: string;
         text?: string;
         link?: string;
+        video?: string;
+        audio?: string;
     };
     /**
      * Function that dynamically imports style sheet
@@ -681,7 +877,7 @@ declare interface SkinOptions {
 
 export declare function StandaloneRoute({ app }: StandaloneRouteProps): JSX_2.Element;
 
-declare interface StandaloneRouteProps {
+export declare interface StandaloneRouteProps {
     app: App;
 }
 
@@ -697,7 +893,9 @@ export { StorageManager_2 as StorageManager }
 
 export declare class SystemManager {
     #private;
+    /** The name of the system */
     readonly systemName: string;
+    /** The tagline/short description of the system */
     readonly tagLine: string;
     readonly skin: Skin;
     readonly appsConfig: AppsConfig;
@@ -713,7 +911,9 @@ export declare class SystemManager {
     getUptime(precision?: number): string;
 }
 
-declare interface SystemManagerParams {
+export declare const SystemManagerContext: Context<SystemManager | undefined>;
+
+export declare interface SystemManagerParams {
     systemName: SystemManager["systemName"] | null;
     tagLine: SystemManager["tagLine"] | null;
     skin?: SystemManager["skin"];
@@ -727,6 +927,9 @@ declare interface SystemManagerParams {
     virtualDriveConfig: VirtualDriveConfig;
 }
 
+/**
+ * Component that renders the start and search menus, pinned applications and various indicators
+ */
 export declare const Taskbar: MemoExoticComponent<() => JSX_2.Element>;
 
 export declare class TaskbarConfig {
@@ -734,7 +937,7 @@ export declare class TaskbarConfig {
     constructor(options?: Partial<TaskbarConfigOptions>);
 }
 
-declare interface TaskbarConfigOptions {
+export declare interface TaskbarConfigOptions {
     /**
      * Height of the taskbar in CSS pixels
      * @default 3 * 16
@@ -744,7 +947,7 @@ declare interface TaskbarConfigOptions {
 
 export declare function TextDisplay({ children }: TextDisplayProps): JSX_2.Element;
 
-declare interface TextDisplayProps {
+export declare interface TextDisplayProps {
     children: ReactNode;
 }
 
@@ -771,7 +974,7 @@ export declare class TimeManager {
 
 export declare function ToggleAction({ actionId, label, shortcut, initialValue, onTrigger }: ToggleActionProps): ReactElement;
 
-declare interface ToggleActionProps extends ActionProps {
+export declare interface ToggleActionProps extends ActionProps {
     initialValue: boolean;
 }
 
@@ -781,7 +984,7 @@ export declare class TrackingConfig {
     constructor(options?: Partial<TrackingConfigOptions>);
 }
 
-declare interface TrackingConfigOptions {
+export declare interface TrackingConfigOptions {
     /**
      * Enable tracking
      * @default true
@@ -799,65 +1002,132 @@ export declare class TrackingManager {
     event(options: UaEventOptions | string): void;
 }
 
-declare type TrackingManagerState = TrackingManager | undefined;
+export declare const TrackingManagerContext: Context<TrackingManagerState>;
+
+export declare type TrackingManagerState = TrackingManager | undefined;
 
+/** Returns a function that opens an alert modal */
 export declare function useAlert(): {
-    alert: ({ title, text, iconUrl, size, single }: AlertParams) => void;
+    alert: (params: AlertParams) => void;
 };
 
+/**
+ * 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
+ */
+export declare function useBoolSetting(path: SettingsPath, key: string, defaultValue?: boolean): [boolean, (value: string | boolean) => void];
+
 /**
  * Combine class names and an optional static class name
  */
 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
+ */
 export declare function useContextMenu({ Actions }: UseContextMenuParams): {
     onContextMenu: (event: MouseEvent_2<HTMLElement, MouseEvent_2>, params?: object) => Modal;
     ShortcutsListener: () => JSX_2.Element;
 };
 
-declare interface UseContextMenuParams {
+export declare interface UseContextMenuParams {
+    /** The component with the actions of the context menu */
     Actions: FC<ActionsProps>;
 }
 
+/**
+ * Returns an object that handles stateful history with undo and redo methods
+ */
 export declare function useHistory<Type>(initialState: Type): {
+    /** The entries of the history */
     history: Type[];
+    /** The index of the active entry in list of entries */
     stateIndex: number;
+    /** Adds a new entry to the history */
     pushState: (state: Type) => void;
+    /** Moves backwards in the history */
     undo: () => void;
+    /** 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
+ */
+export declare function useIntSetting(path: SettingsPath, key: string, defaultValue?: number): [number, (value: string | number) => void];
+
+/**
+ * Creates listeners for `"keydown"` and `"keyup"` events
+ */
 export declare function useKeyboardListener({ onKeyDown, onKeyUp }: UseKeyboardListenerParams): void;
 
-declare interface UseKeyboardListenerParams {
+export declare interface UseKeyboardListenerParams {
+    /** Function that handles `"keydown"` events */
     onKeyDown?: (event: KeyboardEvent) => void;
+    /** 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
+ */
+export declare function useListSetting(path: SettingsPath, key: string, defaultValue?: string[]): [string[], (value: string | string[]) => void];
+
 export declare function useModalsManager(): ModalsManagerState;
 
+/**
+ * Creates listeners for `"mousedown"`, `"mouseup"`, `"click"` and `"contextmenu"` events
+ */
 export declare function useMouseListener({ onMouseDown, onMouseUp, onClick, onContextMenu }: UseMouseListenerParams): void;
 
-declare interface UseMouseListenerParams {
+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;
 }
 
+/**
+ * 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 */
     avoidTaskbar: boolean;
 }): {
+    /** The React ref of the element */
     ref: Ref<HTMLElement>;
     initiated: boolean;
+    /** 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`) */
     alignTop: boolean;
 };
 
+/**
+ * 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): {
@@ -867,7 +1137,7 @@ export declare function useScrollWithShadow(params: UseScrollWithShadowParams):
     }) => void;
 };
 
-declare interface UseScrollWithShadowParams {
+export declare interface UseScrollWithShadowParams {
     ref?: MutableRefObject<HTMLElement>;
     horizontal?: boolean;
     dynamicOffset?: boolean;
@@ -885,14 +1155,25 @@ 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
+ */
+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;
 
 /**
- * TO DO: rewrite to use a global shortcuts manager instead, to allow certain shortcuts to be prioritized and prevent conflicts
+ * Creates listeners for keyboard shortcuts
  */
 export declare function useShortcuts({ options, shortcuts, useCategories }: UseShortcutsParams): void;
 
-declare interface UseShortcutsParams {
+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;
@@ -903,6 +1184,15 @@ declare interface UseShortcutsParams {
  */
 export declare function useStaticClassName(block?: string, element?: string, modifier?: string | string[]): string | null;
 
+/**
+ * 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];
+
 export declare function useSystemManager(): SystemManager;
 
 export declare function useTrackingManager(): TrackingManagerState;
@@ -917,7 +1207,7 @@ export declare function useWindowsManager(): WindowsManagerState;
 
 export declare function useZIndex({ groupIndex, index }: UseZIndexParams): number;
 
-declare interface UseZIndexParams {
+export declare interface UseZIndexParams {
     groupIndex: number;
     index: number;
 }
@@ -942,17 +1232,30 @@ export declare class Vector2 {
     static lerp(vector2A: Vector2, vector2B: Vector2, t: number): Vector2;
 }
 
+export declare const VIDEO_EXTENSIONS: string[];
+
 declare class VirtualBase extends EventEmitter<EventNamesMap> {
+    /** The name of this item */
     name: string;
+    /** The alias of this item */
     alias: string | undefined | null;
+    /** The folder this item is in */
     parent: VirtualFolder | undefined | null;
+    /** Whether this item is protected from changes */
     isProtected: boolean | undefined | null;
+    /** The URL of the icon of this item */
     iconUrl: string | undefined | null;
+    /** The file this item links to */
     linkedFile: VirtualFile | undefined | null;
+    /** The folder this item links to */
     linkedFolder: VirtualFolder | undefined | null;
+    /** Whether this item has been edited by the user */
     editedByUser: boolean | undefined | null;
+    /** Whether this item is the root folder */
     isRoot: boolean | undefined | null;
+    /** The root folder */
     root: VirtualRoot | undefined | null;
+    /** Whether this item has been deleted */
     isDeleted: boolean;
     static EVENT_NAMES: {
         update: string;
@@ -966,9 +1269,18 @@ declare class VirtualBase extends EventEmitter<EventNamesMap> {
     setIconUrl(iconUrl: string | null): this;
     getIconUrl(): string;
     getType(): string;
+    /**
+     * Tries to delete this item
+     */
     delete(): void;
     confirmChanges(root?: VirtualRoot): void;
+    /**
+     * Opens this item in the appropriate application
+     */
     open(..._args: unknown[]): unknown;
+    /**
+     * Returns the path of this item
+     */
     get path(): string;
     /**
      * Returns path without using this item's alias
@@ -982,6 +1294,9 @@ declare class VirtualBase extends EventEmitter<EventNamesMap> {
      * Returns whether this can be edited in its current state
      */
     get canBeEdited(): boolean;
+    /**
+     * Returns the root folder
+     */
     getRoot(): VirtualRoot;
     isFile(): boolean;
     isFolder(): boolean;
@@ -1000,7 +1315,7 @@ export declare class VirtualDriveConfig {
     constructor(options?: Partial<VirtualDriveConfigOptions>);
 }
 
-declare interface VirtualDriveConfigOptions {
+export declare interface VirtualDriveConfigOptions {
     /**
      * Enables persistent storage of the virtual drive
      * @default true
@@ -1043,8 +1358,11 @@ declare interface VirtualDriveConfigOptions {
  * A virtual file that can be stored inside a folder
  */
 export declare class VirtualFile extends VirtualBase {
+    /** The extension of this file */
     extension: OptionalStringProperty;
+    /** The URL of the source of this file */
     source: OptionalStringProperty;
+    /** The content of this file */
     content: OptionalStringProperty;
     static NON_TEXT_EXTENSIONS: string[];
     static EVENT_NAMES: {
@@ -1074,11 +1392,13 @@ export declare class VirtualFile extends VirtualBase {
     isFile(): boolean;
     getIconUrl(): string;
     getType(): string;
+    download(): void;
+    isDownloadable(): boolean;
     toJSON(): VirtualFileJson | null;
     static removeFileScheme(source: string): string;
 }
 
-declare interface VirtualFileJson extends VirtualBaseJson {
+export declare interface VirtualFileJson extends VirtualBaseJson {
     ext?: string;
     cnt?: string;
     src?: string;
@@ -1103,7 +1423,7 @@ export declare class VirtualFileLink extends VirtualFile {
     getIconUrl(...args: Parameters<VirtualFile["getIconUrl"]>): ReturnType<VirtualFile["getIconUrl"]>;
 }
 
-declare interface VirtualFileLinkJson extends VirtualFileJson {
+export declare interface VirtualFileLinkJson extends VirtualFileJson {
     lnk: string;
 }
 
@@ -1111,8 +1431,14 @@ declare interface VirtualFileLinkJson extends VirtualFileJson {
  * A virtual folder that can contains files and sub-folders
  */
 export declare class VirtualFolder extends VirtualBase {
+    /** The folders inside this folder */
     subFolders: (VirtualFolder | VirtualFolderLink)[];
+    /** The files inside this folder */
     files: (VirtualFile | VirtualFileLink)[];
+    /**
+     * The type of this folder
+     * @default VirtualFolder.TYPE.general
+     */
     type: number | undefined;
     static TYPE: {
         general: number;
@@ -1209,7 +1535,7 @@ export declare class VirtualFolder extends VirtualBase {
     toJSON(): VirtualFolderJson | null;
 }
 
-declare interface VirtualFolderJson extends VirtualBaseJson {
+export declare interface VirtualFolderJson extends VirtualBaseJson {
     fls?: VirtualFileJson[];
     fds?: VirtualFolderJson[];
 }
@@ -1240,7 +1566,7 @@ export declare class VirtualFolderLink extends VirtualFolder {
     getItemCount(...args: Parameters<VirtualFolder["getItemCount"]>): ReturnType<VirtualFolder["getItemCount"]>;
 }
 
-declare interface VirtualFolderLinkJson extends VirtualFolderJson {
+export declare interface VirtualFolderLinkJson extends VirtualFolderJson {
     lnk: string;
 }
 
@@ -1248,6 +1574,7 @@ declare interface VirtualFolderLinkJson extends VirtualFolderJson {
  * A virtual folder that serves as the root folder
  */
 export declare class VirtualRoot extends VirtualFolder {
+    /** Aliases for files and folders */
     shortcuts: Record<string, VirtualFile | VirtualFileLink | VirtualFolder | VirtualFolderLink>;
     initiated: boolean;
     loadedDefaultData: boolean;
@@ -1264,7 +1591,7 @@ export declare class VirtualRoot extends VirtualFolder {
      */
     saveData(): void;
     /**
-     * Initiates 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;
     /**
@@ -1275,34 +1602,47 @@ export declare class VirtualRoot extends VirtualFolder {
      * Tells the storage manager to clear all data and reloads the window
      */
     reset(): void;
-    static isValidName(_name: string): void;
-    static isValidFileName(_name: string): void;
-    static isValidFolderName(_name: string): void;
+    static isValidName(_name: string): boolean;
+    static isValidFileName(_name: string): boolean;
+    static isValidFolderName(_name: string): boolean;
     get path(): string;
     get displayPath(): string;
     toJSON(): VirtualRootJson | null;
     toString(): string | null;
 }
 
-declare interface VirtualRootJson extends VirtualFolderJson {
+export declare const VirtualRootContext: Context<VirtualRootState>;
+
+export declare interface VirtualRootJson extends VirtualFolderJson {
     scs: Record<string, string>;
 }
 
-declare type VirtualRootState = VirtualRoot | undefined;
+export declare type VirtualRootState = VirtualRoot | undefined;
 
+/**
+ * Component that renders an external application inside an iframe
+ */
 export declare const WebView: FC<WebViewProps>;
 
-declare interface WebViewProps extends WindowProps {
+export declare interface WebViewProps extends WindowProps {
+    /** The URL of the external application */
     source?: string;
     title?: string;
 }
 
 export declare function WindowedModal({ modal, params, children, ...props }: ModalProps): JSX_2.Element;
 
-declare interface WindowOptions {
+export declare interface WindowOptions {
+    /** The ID of the window */
     id?: string;
+    /** The app associated with the window */
     app?: App;
+    /**
+     * The size of the window
+     * @default new Vector2(700, 400)
+     */
     size?: Vector2;
+    /** The position of the window */
     position?: Vector2;
     fullscreen?: boolean | string;
     options?: object;
@@ -1312,22 +1652,31 @@ declare interface WindowOptions {
     [key: string]: unknown;
 }
 
-declare interface WindowOptions_2 {
-    size?: Vector2;
-    [key: string]: unknown;
-}
-
 export declare interface WindowProps extends WindowOptions {
+    /**
+     * 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 */
     setTitle?: React.Dispatch<React.SetStateAction<string>>;
+    /** 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 */
     active?: boolean;
+    /** Whether to start the window in minimized mode */
     minimized?: boolean;
+    /** Function that toggles the minimized mode of the window */
     toggleMinimized?: (event?: Event) => void;
+    /** The depth value of the window */
     index?: number;
+    /** Whether the window is in standalone mode */
     standalone?: boolean;
 }
 
@@ -1338,12 +1687,14 @@ export declare class WindowsConfig {
     constructor(options?: Partial<WindowsConfigOptions>);
 }
 
-declare interface WindowsConfigOptions {
+export declare interface WindowsConfigOptions {
     /**
+     * The margin around windows that are not maximized, in pixels
      * @default 32
      */
     screenMargin: number;
     /**
+     * The separator to use in window titles
      * @default "-"
      */
     titleSeparator: string;
@@ -1354,16 +1705,21 @@ declare interface WindowsConfigOptions {
     minScreenSize: Vector2;
 }
 
+/**
+ * Manages the states of windows
+ */
 export declare class WindowsManager {
     #private;
     windows: {
         [id: string]: WindowOptions;
     };
+    /** Function that handles changes to the open windows */
     updateWindows: (window: WindowsManager["windows"]) => void;
     startupComplete: boolean;
     constructor(systemManager: SystemManager, trackingManager: TrackingManager);
     /**
-     * Open a window for an app
+     * Opens a window for an application
+     * @param appId The ID of the app
      */
     open(appId: string, options?: WindowOptions | null): object | null;
     /**
@@ -1409,11 +1765,24 @@ export declare class WindowsManager {
     get windowIds(): string[];
 }
 
-declare type WindowsManagerState = WindowsManager | undefined;
+export declare const WindowsManagerContext: Context<WindowsManagerState>;
 
+export declare type WindowsManagerState = WindowsManager | undefined;
+
+/**
+ * Component that renders the windows for all currently active applications
+ */
 export declare const WindowsView: FC;
 
-declare class ZIndexGroup {
+/**
+ * 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
+ */
+export declare class ZIndexGroup {
     length: number;
     offset: number;
     groupIndex: number;