tiny-essentials 1.28.1 → 1.28.3

package/dist/v1/libs/TinyInventory.d.mts

@@ -1,6 +1,13 @@
-export default TinyInventory;
 /**
  * Represents a registered item definition in the global registry.
+ *
+ * @typedef {Object} ItemDef
+ * @property {string} id - Unique identifier for the item.
+ * @property {number} weight - Weight of a single unit of the item.
+ * @property {InventoryMetadata} metadata - Default metadata for the item type.
+ * @property {number} maxStack - Maximum quantity per stack.
+ * @property {OnUseEvent|null} onUse - Callback triggered when the item is used.
+ * @property {string|null} type - Optional category/type identifier.
  */
 export type ItemDef = {
     /**
@@ -28,9 +35,6 @@ export type ItemDef = {
      */
     type: string | null;
 };
-/**
- * Represents an individual stored item instance in the inventory.
- */
 export type InventoryItem = {
     /**
      * - Unique identifier for the item.
@@ -45,17 +49,8 @@ export type InventoryItem = {
      */
     quantity: number;
 };
-/**
- * A collection of item stacks stored in the inventory.
- */
 export type InvSlots = (InventoryItem | null)[];
-/**
- * Metadata object used to store arbitrary key-value pairs for an item.
- */
 export type InventoryMetadata = Record<string | number | symbol, any>;
-/**
- * Represents a special slot (e.g., equipment) in the inventory.
- */
 export type SpecialSlot = {
     /**
      * - Optional slot category/type.
@@ -66,53 +61,20 @@ export type SpecialSlot = {
      */
     item: InventoryItem | null;
 };
-/**
- * Generic event callback triggered by inventory actions.
- */
 export type OnEvent = (payload: EventPayload) => void;
-/**
- * Event fired when an item is added to the inventory.
- */
 export type AddItemEvent = OnEvent;
-/**
- * Event fired when an item is setted to the inventory.
- */
 export type SetItemEvent = OnEvent;
-/**
- * Event fired when an item is removed from the inventory.
- */
 export type RemoveItemEvent = OnEvent;
-/**
- * Event fired when an item is used.
- */
 export type UseItemEvent = OnEvent;
-/**
- * A function executed when an inventory item is used.
- * Can be assigned to handle custom "on use" behavior.
- */
 export type OnUseEvent = OnEvent;
-/**
- * Represents the supported event types for inventory actions.
- */
-export type EventsType = "add" | "remove" | "use" | "set";
-/**
- * Callback used to filter items by matching metadata.
- */
+export type EventsType = 'add' | 'remove' | 'use' | 'set';
 export type GetItemsByMetadataCallback = (metadata: InventoryMetadata, item: InventoryItem) => boolean;
-/**
- * Callback used when searching for an item in an inventory collection.
- * Works similarly to `Array.prototype.find()` conditions.
- */
 export type FindItemCallback = (value: InventoryItem, index: number, items: InventoryItem[]) => boolean;
-/**
- * Represents the fully serialized structure of a TinyInventory instance.
- * Intended for pure JSON storage and transmission.
- */
 export type SerializedInventory = {
     /**
      * - Schema identifier for validation.
      */
-    __schema: "TinyInventory";
+    __schema: 'TinyInventory';
     /**
      * - Serialized format version.
      */
@@ -142,13 +104,7 @@ export type SerializedInventory = {
      */
     specialSlots: Record<string, SpecialSlot>;
 };
-/**
- * Represents an entry from the inventory as a pair containing the item and its index in the collection.
- */
 export type ItemListData = [InventoryItem, number];
-/**
- * Payload data dispatched when an inventory event occurs (e.g., add, remove, equip, unequip).
- */
 export type EventPayload = {
     /**
      * - Index of the item in its collection (null if not applicable).
@@ -171,9 +127,6 @@ export type EventPayload = {
      */
     remove: (forceSpace: boolean) => void;
 };
-/**
- * Result of adding items to an inventory.
- */
 export type AddItemResult = {
     /**
      * - Quantity of the item that could NOT be added due to space/stack limits.
@@ -187,17 +140,6 @@ export type AddItemResult = {
         quantity: number;
     }[];
 };
-/**
- * Represents a registered item definition in the global registry.
- *
- * @typedef {Object} ItemDef
- * @property {string} id - Unique identifier for the item.
- * @property {number} weight - Weight of a single unit of the item.
- * @property {InventoryMetadata} metadata - Default metadata for the item type.
- * @property {number} maxStack - Maximum quantity per stack.
- * @property {OnUseEvent|null} onUse - Callback triggered when the item is used.
- * @property {string|null} type - Optional category/type identifier.
- */
 /**
  * Represents an individual stored item instance in the inventory.
  *
@@ -323,12 +265,7 @@ export type AddItemResult = {
  * @beta
  */
 declare class TinyInventory {
-    /**
-     * Registry of all item definitions available in TinyInventory.
-     * Keys are item IDs, values are configuration objects created with {@link TinyInventory.defineItem}.
-     * @type {Map<string, ItemDef>}
-     */
-    static #ItemRegistry: Map<string, ItemDef>;
+    #private;
     /**
      * Returns a deep-cloned snapshot of all registered items.
      * Ensures the caller cannot mutate the internal registry.
@@ -351,11 +288,11 @@ declare class TinyInventory {
      */
     static defineItem(config: {
         id: string;
-        weight?: number | undefined;
-        metadata?: InventoryMetadata | undefined;
-        maxStack?: number | undefined;
-        onUse?: OnEvent | null | undefined;
-        type?: string | null | undefined;
+        weight?: number;
+        metadata?: InventoryMetadata;
+        maxStack?: number;
+        onUse?: OnUseEvent | null;
+        type?: string | null;
     }): void;
     /**
      * Removes an item definition from the global registry.
@@ -380,39 +317,10 @@ declare class TinyInventory {
      */
     static getItem(itemId: string): ItemDef;
     /**
-     * Rebuilds a TinyInventory from a plain object created by {@link TinyInventory.toObject}.
-     * Item definitions (ItemRegistry) must be already defined externally; this method only restores state.
-     *
-     * @param {SerializedInventory} obj - Parsed JSON object.
-     * @returns {TinyInventory} A new TinyInventory instance populated with the saved state.
-     * @throws {Error} If validation fails and `validate` is true.
-     */
-    static fromObject(obj: SerializedInventory): TinyInventory;
-    /**
-     * Rebuilds a TinyInventory from a JSON string produced by {@link TinyInventory.toJSON}.
-     * @param {string} json - JSON string.
-     * @returns {TinyInventory} A new TinyInventory instance.
-     */
-    static fromJSON(json: string): TinyInventory;
-    /**
-     * Creates a new TinyInventory instance.
-     *
-     * @param {Object} [options={}] - Configuration options for the inventory.
-     * @param {number|null} [options.maxWeight=null] - Maximum allowed total weight (null for no limit).
-     * @param {number|null} [options.maxSlots=null] - Maximum number of item slots (null for no limit).
-     * @param {number|null} [options.maxSize=null] - Maximum number of total item amount (null for no limit).
-     * @param {number} [options.maxStack=Infinity] - Global maximum stack size (per slot).
-     * @param {Record<string, { type: string | null; }>} [options.specialSlots] - IDs for special slots (e.g., "helmet", "weapon").
+     * Gets the maximum stack size allowed per item.
+     * @returns {number}
      */
-    constructor(options?: {
-        maxWeight?: number | null | undefined;
-        maxSlots?: number | null | undefined;
-        maxSize?: number | null | undefined;
-        maxStack?: number | undefined;
-        specialSlots?: Record<string, {
-            type: string | null;
-        }> | undefined;
-    });
+    get maxStack(): number;
     /**
      * Sets the maximum stack size per item.
      * @param {number} value - Must be a positive integer.
@@ -420,10 +328,10 @@ declare class TinyInventory {
      */
     set maxStack(value: number);
     /**
-     * Gets the maximum stack size allowed per item.
-     * @returns {number}
+     * Gets the maximum item size allowed.
+     * @returns {number|null}
      */
-    get maxStack(): number;
+    get maxSize(): number | null;
     /**
      * Sets the maximum item size.
      * @param {number|null} value - Must be a positive integer or null.
@@ -431,10 +339,10 @@ declare class TinyInventory {
      */
     set maxSize(value: number | null);
     /**
-     * Gets the maximum item size allowed.
+     * Gets the maximum number of slots allowed.
      * @returns {number|null}
      */
-    get maxSize(): number | null;
+    get maxSlots(): number | null;
     /**
      * Sets the maximum number of slots.
      * @param {number|null} value - Must be a positive integer or null.
@@ -442,21 +350,16 @@ declare class TinyInventory {
      */
     set maxSlots(value: number | null);
     /**
-     * Gets the maximum number of slots allowed.
+     * Gets the maximum inventory weight allowed.
      * @returns {number|null}
      */
-    get maxSlots(): number | null;
+    get maxWeight(): number | null;
     /**
      * Sets the maximum inventory weight.
      * @param {number|null} value - Must be a positive number or null.
      * @throws {Error} If the value is not null or a positive number.
      */
     set maxWeight(value: number | null);
-    /**
-     * Gets the maximum inventory weight allowed.
-     * @returns {number|null}
-     */
-    get maxWeight(): number | null;
     /**
      * Gets the registered inventory event listeners.
      * Always returns a clone to prevent external mutation.
@@ -503,6 +406,25 @@ declare class TinyInventory {
      * @private
      */
     private _cleanNulls;
+    /**
+     * Creates a new TinyInventory instance.
+     *
+     * @param {Object} [options={}] - Configuration options for the inventory.
+     * @param {number|null} [options.maxWeight=null] - Maximum allowed total weight (null for no limit).
+     * @param {number|null} [options.maxSlots=null] - Maximum number of item slots (null for no limit).
+     * @param {number|null} [options.maxSize=null] - Maximum number of total item amount (null for no limit).
+     * @param {number} [options.maxStack=Infinity] - Global maximum stack size (per slot).
+     * @param {Record<string, { type: string | null; }>} [options.specialSlots] - IDs for special slots (e.g., "helmet", "weapon").
+     */
+    constructor(options?: {
+        maxWeight?: number | null;
+        maxSlots?: number | null;
+        maxSize?: number | null;
+        maxStack?: number;
+        specialSlots?: Record<string, {
+            type: string | null;
+        }>;
+    });
     /**
      * Checks if there is available space based on slot and weight limits.
      * @param {Object} [settings={}] - Optional configuration for the space check.
@@ -512,9 +434,9 @@ declare class TinyInventory {
      * @returns {boolean} True if there is space; false otherwise.
      */
     hasSpace({ weight, sizeLength, slotsLength }?: {
-        weight?: number | undefined;
-        sizeLength?: number | undefined;
-        slotsLength?: number | undefined;
+        weight?: number;
+        sizeLength?: number;
+        slotsLength?: number;
     }): boolean;
     /**
      * Checks if the inventory weight exceeds the maximum allowed limit,
@@ -608,9 +530,9 @@ declare class TinyInventory {
      */
     addItem({ itemId, quantity, metadata, forceSpace }: {
         itemId: string;
-        forceSpace?: boolean | undefined;
-        quantity?: number | undefined;
-        metadata?: InventoryMetadata | undefined;
+        forceSpace?: boolean;
+        quantity?: number;
+        metadata?: InventoryMetadata;
     }): AddItemResult;
     /**
      * Gets the item stored at a specific slot.
@@ -632,7 +554,7 @@ declare class TinyInventory {
     setItem({ slotIndex, item, forceSpace }: {
         slotIndex: number;
         item: InventoryItem | null;
-        forceSpace?: boolean | undefined;
+        forceSpace?: boolean;
     }): void;
     /**
      * Deletes an item from a specific slot by setting it to null.
@@ -660,8 +582,8 @@ declare class TinyInventory {
      */
     removeItem({ itemId, metadata, quantity }: {
         itemId: string;
-        metadata?: InventoryMetadata | null | undefined;
-        quantity?: number | undefined;
+        metadata?: InventoryMetadata | null;
+        quantity?: number;
     }): boolean;
     /**
      * Uses an item from a specific slot, or special slot,
@@ -677,9 +599,9 @@ declare class TinyInventory {
      * @throws {Error} - If the item is not found in the specified location.
      */
     useItem({ slotIndex, specialSlot, forceSpace }: {
-        slotIndex?: number | undefined;
-        specialSlot?: string | undefined;
-        forceSpace?: boolean | undefined;
+        slotIndex?: number;
+        specialSlot?: string;
+        forceSpace?: boolean;
     }, ...args: any[]): any;
     /**
      * Checks if a special slot with the given ID exists in the inventory.
@@ -713,7 +635,7 @@ declare class TinyInventory {
     setSpecialSlot({ slotId, item, forceSpace }: {
         slotId: string;
         item: InventoryItem | null;
-        forceSpace?: boolean | undefined;
+        forceSpace?: boolean;
     }): void;
     /**
      * Deletes an item from a specific special slot by setting it to null.
@@ -743,8 +665,8 @@ declare class TinyInventory {
     equipItem({ slotId, slotIndex, quantity, forceSpace }: {
         slotId: string;
         slotIndex: number;
-        quantity?: number | undefined;
-        forceSpace?: boolean | undefined;
+        quantity?: number;
+        forceSpace?: boolean;
     }): number;
     /**
      * Unequips a specific quantity of an item from a special slot
@@ -761,8 +683,8 @@ declare class TinyInventory {
      */
     unequipItem({ slotId, quantity, forceSpace }: {
         slotId: string;
-        quantity?: number | null | undefined;
-        forceSpace?: boolean | undefined;
+        quantity?: number | null;
+        forceSpace?: boolean;
     }): boolean;
     /**
      * Returns all items from the inventory with their respective indexes.
@@ -866,6 +788,21 @@ declare class TinyInventory {
      * @returns {string} JSON string.
      */
     toJSON(space?: number): string;
-    #private;
+    /**
+     * Rebuilds a TinyInventory from a plain object created by {@link TinyInventory.toObject}.
+     * Item definitions (ItemRegistry) must be already defined externally; this method only restores state.
+     *
+     * @param {SerializedInventory} obj - Parsed JSON object.
+     * @returns {TinyInventory} A new TinyInventory instance populated with the saved state.
+     * @throws {Error} If validation fails and `validate` is true.
+     */
+    static fromObject(obj: SerializedInventory): TinyInventory;
+    /**
+     * Rebuilds a TinyInventory from a JSON string produced by {@link TinyInventory.toJSON}.
+     * @param {string} json - JSON string.
+     * @returns {TinyInventory} A new TinyInventory instance.
+     */
+    static fromJSON(json: string): TinyInventory;
 }
+export default TinyInventory;
 //# sourceMappingURL=TinyInventory.d.mts.map

package/dist/v1/libs/TinyInventoryTrader.d.mts

@@ -1,34 +1,31 @@
-export default TinyInventoryTrader;
-export type InventoryMetadata = import("./TinyInventory.mjs").InventoryMetadata;
-export type AddItemResult = import("./TinyInventory.mjs").AddItemResult;
-/**
- * - Transfer configuration.
- */
+import TinyInventory from './TinyInventory.mjs';
+export type InventoryMetadata = import('./TinyInventory.mjs').InventoryMetadata;
+export type AddItemResult = import('./TinyInventory.mjs').AddItemResult;
 export type TransferItemCfg = {
     /**
      * - Sender slot index.
      */
-    slotIndex?: number | undefined;
+    slotIndex?: number;
     /**
      * - Receiver slot index (optional).
      */
-    receiverSlotIndex?: number | undefined;
+    receiverSlotIndex?: number;
     /**
      * - Sender special slot ID.
      */
-    specialSlot?: string | undefined;
+    specialSlot?: string;
     /**
      * - Quantity to transfer.
      */
-    quantity?: number | undefined;
+    quantity?: number;
     /**
      * - Whether to force addition even if space is limited.
      */
-    forceSpace?: boolean | undefined;
+    forceSpace?: boolean;
     /**
      * - If true, transfer will throw if not all items can fit.
      */
-    strict?: boolean | undefined;
+    strict?: boolean;
 };
 /** @typedef {import('./TinyInventory.mjs').InventoryMetadata} InventoryMetadata */
 /** @typedef {import('./TinyInventory.mjs').AddItemResult} AddItemResult */
@@ -45,20 +42,21 @@ export type TransferItemCfg = {
  * Class responsible for managing item transfers between two TinyInventory instances.
  */
 declare class TinyInventoryTrader {
+    #private;
+    /** @returns {TinyInventory|null} The currently connected sender inventory. */
+    get sender(): TinyInventory | null;
+    /** @returns {TinyInventory|null} The currently connected receiver inventory. */
+    get receiver(): TinyInventory | null;
+    /** @param {TinyInventory} value Sets the sender inventory. */
+    set sender(value: TinyInventory);
+    /** @param {TinyInventory} value Sets the receiver inventory. */
+    set receiver(value: TinyInventory);
     /**
      * Manages item transfers between two TinyInventory instances.
      * @param {TinyInventory} [sender] - Inventory to remove items from.
      * @param {TinyInventory} [receiver] - Inventory to add items to.
      */
     constructor(sender?: TinyInventory, receiver?: TinyInventory);
-    /** @param {TinyInventory} value Sets the sender inventory. */
-    set sender(value: TinyInventory);
-    /** @returns {TinyInventory|null} The currently connected sender inventory. */
-    get sender(): TinyInventory | null;
-    /** @param {TinyInventory} value Sets the receiver inventory. */
-    set receiver(value: TinyInventory);
-    /** @returns {TinyInventory|null} The currently connected receiver inventory. */
-    get receiver(): TinyInventory | null;
     /**
      * Connects the sender and receiver inventories for trading.
      * @param {TinyInventory} sender - Inventory to remove items from.
@@ -89,7 +87,6 @@ declare class TinyInventoryTrader {
      * @returns {Partial<AddItemResult>[]} Array of remaining quantities for each item.
      */
     transferMultiple(items: TransferItemCfg[]): Partial<AddItemResult>[];
-    #private;
 }
-import TinyInventory from './TinyInventory.mjs';
+export default TinyInventoryTrader;
 //# sourceMappingURL=TinyInventoryTrader.d.mts.map

package/dist/v1/libs/TinyLevelUp.d.mts

@@ -1,6 +1,10 @@
-export default TinyLevelUp;
 /**
  * Represents a user object used.
+ *
+ * @typedef {Object} UserEditor
+ * @property {number} exp - Current experience points of the user.
+ * @property {number} level - Current level of the user.
+ * @property {number} totalExp - Total accumulated experience.
  */
 export type UserEditor = {
     /**
@@ -16,26 +20,18 @@ export type UserEditor = {
      */
     totalExp: number;
 };
-/**
- * Represents a user object used.
- *
- * @typedef {Object} UserEditor
- * @property {number} exp - Current experience points of the user.
- * @property {number} level - Current level of the user.
- * @property {number} totalExp - Total accumulated experience.
- */
 /**
  * Class to manage user level-up logic based on experience points.
  */
 declare class TinyLevelUp {
+    giveExp: number;
+    expLevel: number;
     /**
      * Constructor
      * @param {number} giveExp - Base experience value for random experience generation.
      * @param {number} expLevel - Base experience needed to level up (per level).
      */
     constructor(giveExp: number, expLevel: number);
-    giveExp: number;
-    expLevel: number;
     /**
      * Creates a new user object starting at level 0 with 0 experience.
      * @returns {UserEditor} A fresh user object.
@@ -128,7 +124,7 @@ declare class TinyLevelUp {
      * @param {number} [multi] - Multiplier for experience generation.
      * @returns {UserEditor} The updated user object.
      */
-    give(user: UserEditor, extraExp?: number, type?: "add" | "extra", multi?: number): UserEditor;
+    give(user: UserEditor, extraExp?: number, type?: 'add' | 'extra', multi?: number): UserEditor;
     /**
      * Removes experience from the user, adjusting their level if necessary.
      * @param {UserEditor} user - The user object.
@@ -137,6 +133,7 @@ declare class TinyLevelUp {
      * @param {number} [multi] - Multiplier for experience generation.
      * @returns {UserEditor} The updated user object.
      */
-    remove(user: UserEditor, extraExp?: number, type?: "add" | "extra", multi?: number): UserEditor;
+    remove(user: UserEditor, extraExp?: number, type?: 'add' | 'extra', multi?: number): UserEditor;
 }
+export default TinyLevelUp;
 //# sourceMappingURL=TinyLevelUp.d.mts.map

package/dist/v1/libs/TinyLoadingScreen.d.mts

@@ -1,15 +1,12 @@
-export default TinyLoadingScreen;
 /**
  * Represents the possible states of the loading screen.
  * - `'none'` → Not visible
  * - `'fadeIn'` → Appearing with fade-in animation
  * - `'active'` → Fully visible and active
  * - `'fadeOut'` → Disappearing with fade-out animation
+ * @typedef {'none'|'active'|'fadeIn'|'fadeOut'} LoadingStatus
  */
-export type LoadingStatus = "none" | "active" | "fadeIn" | "fadeOut";
-/**
- * Configuration options for the loading screen.
- */
+export type LoadingStatus = 'none' | 'active' | 'fadeIn' | 'fadeOut';
 export type LoadingSettings = {
     /**
      * - Duration of fade-in animation in milliseconds, or `null` to disable.
@@ -24,14 +21,6 @@ export type LoadingSettings = {
      */
     zIndex: number;
 };
-/**
- * Represents the possible states of the loading screen.
- * - `'none'` → Not visible
- * - `'fadeIn'` → Appearing with fade-in animation
- * - `'active'` → Fully visible and active
- * - `'fadeOut'` → Disappearing with fade-out animation
- * @typedef {'none'|'active'|'fadeIn'|'fadeOut'} LoadingStatus
- */
 /**
  * Configuration options for the loading screen.
  * @typedef {Object} LoadingSettings
@@ -53,67 +42,68 @@ export type LoadingSettings = {
  * @class
  */
 declare class TinyLoadingScreen {
-    /**
-     * Creates a new TinyLoadingScreen instance.
-     * @param {HTMLElement} [container=document.body] - The container element where the overlay should be appended.
-     * @throws {TypeError} If container is not an HTMLElement.
-     */
-    constructor(container?: HTMLElement);
+    #private;
     /** @returns {HTMLDivElement|null} The overlay element if active, otherwise `null`. */
     get overlay(): HTMLDivElement | null;
     /** @returns {HTMLDivElement|null} The element used to render the message, or `null` if inactive. */
     get messageElement(): HTMLDivElement | null;
     /** @returns {HTMLElement} The container element that holds the overlay. */
     get container(): HTMLElement;
+    /** @returns {LoadingSettings} A copy of the current configuration options. */
+    get options(): LoadingSettings;
     /**
      * Updates the loading screen options.
      * @param {Partial<LoadingSettings>} value - New configuration values.
      * @throws {TypeError} If any option has an invalid type or value.
      */
     set options(value: Partial<LoadingSettings>);
-    /** @returns {LoadingSettings} A copy of the current configuration options. */
-    get options(): LoadingSettings;
     /** @returns {LoadingStatus} The current loading screen status. */
     get status(): LoadingStatus;
+    /** @returns {string|HTMLElement} The default message. */
+    get defaultMessage(): string | HTMLElement;
     /**
      * @param {string|HTMLElement} value - New default message.
      * @throws {TypeError} If the value is neither a string nor an HTMLElement.
      */
     set defaultMessage(value: string | HTMLElement);
-    /** @returns {string|HTMLElement} The default message. */
-    get defaultMessage(): string | HTMLElement;
     /** @returns {string|HTMLElement|null} The currently displayed message. */
     get message(): string | HTMLElement | null;
+    /** @returns {boolean} True if HTML is allowed inside string messages. */
+    get allowHtmlText(): boolean;
     /**
      * Enables or disables HTML rendering in string messages.
      * @param {boolean} value - Whether to allow HTML.
      * @throws {TypeError} If value is not a boolean.
      */
     set allowHtmlText(value: boolean);
-    /** @returns {boolean} True if HTML is allowed inside string messages. */
-    get allowHtmlText(): boolean;
     /** @returns {boolean} Whether a fadeIn timeout is currently pending. */
     get fadeInTimeout(): boolean;
     /** @returns {boolean} Whether a fadeOut timeout is currently pending. */
     get fadeOutTimeout(): boolean;
     /** @returns {boolean} True if the overlay is currently visible. */
     get visible(): boolean;
+    /**
+     * Returns the current status-change callback.
+     * @returns {((status: LoadingStatus) => void) | null}
+     */
+    get onChange(): ((status: LoadingStatus) => void) | null;
     /**
      * Sets the status-change callback.
      * @param {((status: LoadingStatus) => void) | null} value
      * @throws {TypeError} If value is neither a function nor null.
      */
     set onChange(value: ((status: LoadingStatus) => void) | null);
-    /**
-     * Returns the current status-change callback.
-     * @returns {((status: LoadingStatus) => void) | null}
-     */
-    get onChange(): ((status: LoadingStatus) => void) | null;
     /**
      * Internal helper to emit the onChange callback.
      * @private
      */
     private _emitChange;
+    /**
+     * Creates a new TinyLoadingScreen instance.
+     * @param {HTMLElement} [container=document.body] - The container element where the overlay should be appended.
+     * @throws {TypeError} If container is not an HTMLElement.
+     */
+    constructor(container?: HTMLElement);
     /**
      * Internal helper to update the displayed message.
      * @param {string|HTMLElement} [message=this.#defaultMessage] - The new message.
@@ -149,6 +139,6 @@ declare class TinyLoadingScreen {
      * @returns {boolean} `true` if the overlay was removed, `false` if not active.
      */
     stop(): boolean;
-    #private;
 }
+export default TinyLoadingScreen;
 //# sourceMappingURL=TinyLoadingScreen.d.mts.map