@tixyel/streamelements 6.4.9 → 6.5.1

package/dist/index.d.ts

@@ -220,6 +220,69 @@ declare namespace YoutubeEvents {
     }
 }
 
+type TwitchEmote = {
+    type: 'twitch';
+    name: string;
+    id: string;
+    gif: boolean;
+    urls: {
+        '1': string;
+        '2': string;
+        '4': string;
+    };
+    start: number;
+    end: number;
+};
+type SeventvEmote = {
+    type: '7tv';
+    name: string;
+    id: string;
+    gif: boolean;
+    animated: boolean;
+    urls: {
+        '1': string;
+        '2': string;
+        '3': string;
+        '4': string;
+    };
+    start: number;
+    end: number;
+    cords: {
+        x: number;
+        y: number;
+    };
+};
+type BttvEmote = {
+    type: 'bttv';
+    name: string;
+    id: string;
+    gif: boolean;
+    animated: boolean;
+    urls: {
+        '1': string;
+        '2': string;
+        '4': string;
+    };
+    start: number;
+    end: number;
+    coords: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+type Emoji = {
+    type: 'emoji';
+    name: string;
+    id: string;
+    gif: boolean;
+    urls: {
+        '1': string;
+    };
+};
+type Emote = TwitchEmote | BttvEmote | SeventvEmote | Emoji;
+
 type PathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<T[K], Rest> : never : P extends keyof T ? T[P] : never;
 type MapNumberValuesToString<T> = {
     [K in keyof T]: T[K] extends number ? `${T[K]}` | ReturnType<T[K]['toString']> : T[K];
@@ -419,19 +482,6 @@ declare namespace TwitchEvents {
             description: string;
             url: string;
         };
-        type Emote = {
-            type: string;
-            name: string;
-            id: string;
-            gif: boolean;
-            urls: {
-                '1': string;
-                '2': string;
-                '4': string;
-            };
-            start: number;
-            end: number;
-        };
         export {};
     }
     namespace DeleteMessage {
@@ -1570,60 +1620,6 @@ declare namespace StreamElementsEvents {
     }
 }
 
-type TwitchEmote = {
-    type: 'twitch';
-    name: string;
-    id: string;
-    gif: boolean;
-    urls: {
-        '1': string;
-        '2': string;
-        '4': string;
-    };
-    start: number;
-    end: number;
-};
-type SeventvEmote = {
-    type: '7tv';
-    name: string;
-    id: string;
-    gif: boolean;
-    animated: boolean;
-    urls: {
-        '1': string;
-        '2': string;
-        '3': string;
-        '4': string;
-    };
-    start: number;
-    end: number;
-    cords: {
-        x: number;
-        y: number;
-    };
-};
-type BttvEmote = {
-    type: 'bttv';
-    name: string;
-    id: string;
-    gif: boolean;
-    animated: boolean;
-    urls: {
-        '1': string;
-        '2': string;
-        '4': string;
-    };
-    start: number;
-    end: number;
-    coords: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-};
-type Emote = TwitchEmote | BttvEmote | SeventvEmote;
-
 /**
  * EventProvider class for managing event listeners and emitters.
  * This class allows you to register event listeners, emit events, and manage event subscriptions.
@@ -2112,655 +2108,133 @@ declare class useComfyJs extends EventProvider<ComfyEvents> {
     private connect;
 }
 
-declare namespace Helper {
-    namespace number {
-        /**
-         * Translate number to words
-         * @param num - Number to translate
-         * @param type - Translation type
-         * @returns - Number in words
-         * @example
-         * ```javascript
-         * const cardinal = Simulation.number.translate(42, 'cardinal');
-         * console.log(cardinal); // "forty-two"
-         * ```
-         */
-        function translate(num: number, type?: 'cardinal' | 'ordinal' | 'suffix'): string;
-        /**
-         * Balances a number within a specified range
-         * @param amount - Number to balance
-         * @param min - Minimum value
-         * @param max - Maximum value
-         * @param decimals - Number of decimal places to round to (default is 0)
-         * @returns - Balanced number
-         * @example
-         * ```javascript
-         * const balancedValue = Simulation.number.balance(150, 0, 100);
-         * console.log(balancedValue); // 100
-         * ```
-         */
-        function balance(amount: number, min?: number, max?: number, decimals?: number): number;
-        /**
-         * Rounds a number to a specified number of decimal places
-         * @param value - Number to round
-         * @param decimals - Number of decimal places (default is 2)
-         * @returns Rounded number
-         * @example
-         * ```javascript
-         * const roundedValue = Simulation.number.round(3.14159, 3);
-         * console.log(roundedValue); // 3.142
-         * ```
-         */
-        function round(value: number, decimals?: number): number;
-        /**
-         * Generate random number
-         * @param min - Minimum value
-         * @param max - Maximum value
-         * @param float - Number of decimal places (0 for integer)
-         * @returns - Random number
-         * @example
-         * ```javascript
-         * const intNumber = number.random(1, 10);
-         * console.log(intNumber); // e.g. 7
-         *
-         * const floatNumber = number.random(1, 10, 2);
-         * console.log(floatNumber); // e.g. 3.14
-         * ```
-         */
-        function number(min: number, max: number, float?: number): number;
-    }
-    namespace element {
-        interface ScaleOptions<T extends HTMLElement> {
-            /**
-             * The parent element to use for scaling calculations. If not provided, the element's parent will be used.
-             */
-            parent?: HTMLElement;
-            /**
-             * The preferred dimension to base the scaling on. Can be 'width', 'height', or 'auto' (default).
-             */
-            prefer?: 'width' | 'height' | 'auto';
+type BadgeOptions = Twitch.roles[] | Twitch.roles | `${Twitch.roles}/${number}` | `${Twitch.roles}/${number}`[];
+type TwitchResult = {
+    keys: Twitch.roles[];
+    badges: Twitch.badge[];
+    amount: {
+        [K in Twitch.roles]?: number;
+    };
+};
+type YouTubeResult = {
+    isVerified: boolean;
+    isChatOwner: boolean;
+    isChatSponsor: boolean;
+    isChatModerator: boolean;
+};
+declare class MessageHelper {
+    /**
+     * Finds emotes in a given text.
+     * @param text - The text to search for emotes.
+     * @param emotes - An array of emotes to search for. Defaults to Local data emotes.
+     * @returns An array of emotes found in the text with their positions.
+     */
+    findEmotesInText(text: string, emotes?: Emote[]): Emote[];
+    /**
+     * Replaces emotes in the text with corresponding HTML image tags.
+     * @param text - The text containing emotes.
+     * @param emotes - An array of emotes with their positions in the text.
+     * @returns The text with emotes replaced by HTML image tags.
+     */
+    replaceEmotesWithHTML(text: string, emotes: Emote[]): string;
+    /**
+     * Checks if the text contains only emotes and whitespace.
+     * @param text - The text to check.
+     * @param emotes - An array of emotes with their positions in the text.
+     * @returns True if the text contains only emotes and whitespace, false otherwise.
+     */
+    hasOnlyEmotes(text: string, emotes: Emote[]): boolean;
+    /**
+     * Replaces YouTube emotes in the text with corresponding HTML image tags.
+     * @param text - The text containing YouTube emotes.
+     * @param emotes - An array of YouTube emotes. Defaults to Local data YouTube emotes.
+     * @returns The text with YouTube emotes replaced by HTML image tags.
+     */
+    replaceYoutubeEmotesWithHTML(text: string, emotes?: {
+        emojiId: string;
+        shortcuts: string[];
+        searchTerms: string[];
+        image: {
+            thumbnails: {
+                url: string;
+                width: number;
+                height: number;
+            }[];
+            accessibility: {
+                accessibilityData: {
+                    label: string;
+                };
+            };
+        };
+        isCustomEmoji: boolean;
+        index: number;
+    }[]): string;
+    /**
+     * Generates badge data based on the provided badges and platform.
+     * @param badges - The badges to generate. Can be an array or a comma-separated string.
+     * @param provider - The platform provider ('twitch' or 'youtube'). Defaults to 'twitch'.
+     * @returns A promise that resolves to the generated badge data.
+     * @example
+     * ```javascript
+     * // Generate Twitch badges
+     * const twitchBadges = await generateBadges(['broadcaster', 'moderator'], 'twitch');
+     * // Generate YouTube badges
+     * const youtubeBadges = await generateBadges('sponsor, moderator', 'youtube');
+     * ```
+     */
+    generateBadges<T extends Provider$1>(badges: BadgeOptions | undefined, provider: T): Promise<T extends 'twitch' ? TwitchResult : YouTubeResult>;
+}
+
+declare namespace Local {
+    type QueueItem = {
+        listener: 'onEventReceived';
+        data: StreamElements.Event.onEventReceived;
+        session?: boolean;
+    } | {
+        listener: 'onWidgetLoad';
+        data: StreamElements.Event.onWidgetLoad;
+    } | {
+        listener: 'onSessionUpdate';
+        data: StreamElements.Event.onSessionUpdate;
+    };
+    const queue: useQueue<QueueItem>;
+    const generate: {
+        session: {
+            types: Record<string, StreamElements.Session.Config.Any>;
+            available(): StreamElements.Session.Config.Available.Data;
+            get(startSession?: StreamElements.Session.Data): Promise<StreamElements.Session.Data>;
+        };
+        event: {
             /**
-             * The minimum percentage of the parent size to scale to. Default is 0.
+             * Simulates the onWidgetLoad event for a widget.
+             * @param fields - The field values to be included in the event.
+             * @param session - The session data to be included in the event.
+             * @param currency - The currency to be used (default is 'USD').
+             * @returns A Promise that resolves to the simulated onWidgetLoad event data.
              */
-            min?: number;
+            onWidgetLoad(fields: Record<string, StreamElements.CustomField.Value>, session: StreamElements.Session.Data, currency?: "BRL" | "USD" | "EUR"): Promise<StreamElements.Event.onWidgetLoad>;
             /**
-             * The maximum percentage of the parent size to scale to. Default is 1 (100%).
+             * Simulates the onSessionUpdate event for a widget.
+             * @param session - The session data to be included in the event.
+             * @returns A Promise that resolves to the simulated onSessionUpdate event data.
              */
-            max?: number;
+            onSessionUpdate(session?: StreamElements.Session.Data, update?: ClientEvents$1): Promise<StreamElements.Event.onSessionUpdate>;
             /**
-             * A callback function that is called after scaling is applied.
-             * @param this - The HTML element being scaled.
-             * @param number - The scale factor applied to the element.
-             * @param element - The HTML element being scaled.
-             * @returns void
+             * Simulates the onEventReceived event for a widget.
+             * @param provider - The provider of the event (default is 'random').
+             * @param type - The type of event to simulate (default is 'random').
+             * @param options - Additional options to customize the event data.
+             * @returns A Promise that resolves to the simulated onEventReceived event data, or null if the event type is not supported.
+             * @example
+             * ```javascript
+             * // Simulate a random event
+             * const randomEvent = await Local .generate.event.onEventReceived();
+             *
+             * // Simulate a Twitch message event with custom options
+             * const twitchMessageEvent = await Local .generate.event.onEventReceived('twitch', 'message', { name: 'Streamer', message: 'Hello World!' });
+             * ```
              */
-            apply?: (this: T, number: number, element: T) => void;
-        }
-        type FitTextOptions = {
-            minFontSize?: number;
-            maxFontSize?: number;
-            parent?: HTMLElement;
-        };
-        /**
-         * Merges outer span styles with inner span styles in the provided HTML string.
-         * @param outerStyle - The style string to be applied to the outer span.
-         * @param innerHTML - The inner HTML string which may contain a span with its own styles.
-         * @returns A new HTML string with merged styles applied to a single span.
-         * @example
-         * ```javascript
-         * const result = mergeSpanStyles("color: red; font-weight: bold;", '<span style="font-size: 14px;">Hello World</span>');
-         * console.log(result); // Output: '<span style="font-size: 14px; color: red; font-weight: bold;">Hello World</span>'
-         * ```
-         */
-        function mergeSpanStyles(outerStyle: string, innerHTML: string, className?: string): string;
-        /**
-         * Scales an HTML element to fit within its parent element based on specified minimum and maximum scale factors.
-         * @param element - The HTML element to be scaled.
-         * @param min - Minimum scale factor (default is 0).
-         * @param max - Maximum scale factor (default is 1).
-         * @param options - Optional settings for scaling.
-         * @returns - An object containing the new width, height, and scale factor, or void if not applied.
-         * @example
-         * ```javascript
-         * const element = document.getElementById('myElement');
-         * scale(element, 0.5, 1, { return: false });
-         * ```
-         */
-        function scale(element: HTMLElement, min?: number, max?: number, options?: {
-            return: boolean;
-            parent: HTMLElement;
-            base: 'width' | 'height';
-        }): {
-            width: number;
-            height: number;
-            scale: number;
-        } | void;
-        /**
-         * Scales an HTML element to fit within its parent element based on specified options.
-         * @param element - The HTML element to be scaled.
-         * @param options - Optional settings for scaling.
-         * @returns The scale factor applied to the element.
-         * @example
-         * ```javascript
-         * const element = document.getElementById('myElement');
-         * const scaleFactor  scalev2(element, {
-         *   min: 0.5,
-         *   max: 1,
-         *   prefer: 'width',
-         *   apply: (scale, el) => el.style.transform = `scale(${scale})`
-         * });
-         * console.log(`Element scaled by a factor of ${scaleFactor}`);
-         * ```
-         */
-        function scalev2<T extends HTMLElement>(element: T, options?: ScaleOptions<T>): number;
-        /**
-         * Fits the text within the parent element by adjusting the font size.
-         * @param element - The HTML element containing the text to be fitted.
-         * @param compressor - A multiplier to adjust the fitting sensitivity (default is 1).
-         * @param options - Optional settings for fitting text.
-         * @returns The HTML element with adjusted font size.
-         * @example
-         * ```javascript
-         * const element = document.getElementById('myTextElement');
-         * fitText(element, 1, { minFontSize: 12, maxFontSize: 36 });
-         * console.log(`Adjusted font size: ${element.style.fontSize}`);
-         * ```
-         */
-        function fitText(element: HTMLElement, compressor?: number, options?: FitTextOptions): HTMLElement;
-        /**
-         * Wraps formatted HTML text with containers and splits characters into indexed spans.
-         * Adds 'container' class and data-index to all parent elements, and wraps each character in a span with class 'char' and data-index.
-         * @param htmlString - The input HTML string containing formatted text elements (span, strong, em, etc).
-         * @param startIndex - The starting index for the data-index attribute (default is 0).
-         * @returns - A new HTML string with containers and character-level indexing.
-         * @example
-         * ```javascript
-         * const result = splitTextToChars('<span>TesTe</span> <strong>bold</strong>', 0);
-         * console.log(result);
-         * // Output: '<span class="container" data-index="0"><span class="char" data-index="0">T</span><span class="char" data-index="1">e</span>...'
-         * ```
-         */
-        function splitTextToChars(htmlString: string, startIndex?: number, preserveInterElementWhitespace?: boolean): string;
-    }
-    namespace object {
-        /**
-         * Flattens a nested object into a single-level object with dot-separated keys.
-         * @param obj - The nested object to be flattened.
-         * @param prefix  - The prefix to be added to each key (used for recursion).
-         * @returns A flattened object with dot-separated keys.
-         * @example
-         * ```javascript
-         * const nestedObj = { a: { b: 1, c: { d: 2 } }, e: [3, 4] };
-         * const flatObj = flatten(nestedObj);
-         * console.log(flatObj);
-         * // Output: { 'a.b': '1', 'a.c.d': '2', 'e:0': '3', 'e:1': '4' }
-         * ```
-         */
-        function flatten(obj: Record<string, any>, stringify?: boolean, prefix?: string): Record<string, typeof stringify extends true ? string : string | number | boolean>;
-        /**
-         * Returns the entries of an object as an array of key-value pairs, with proper typing.
-         * @param obj - The object to retrieve entries from.
-         * @returns An array of key-value pairs from the object, typed as an array of tuples with key and value types.
-         */
-        function entries<K extends string, V>(obj: Record<K, V>): [K, V][];
-        /**
-         * Returns the values of an object as an array, with proper typing.
-         * @param obj - The object to retrieve values from.
-         * @returns An array of values from the object, typed as an array of the value type.
-         */
-        function values<K extends string, V>(obj: Record<K, V>): V[];
-        /**
-         * Returns the keys of an object as an array of strings, with proper typing.
-         * @param obj - The object to retrieve keys from.
-         * @returns An array of keys from the object, typed as an array of strings.
-         */
-        function keys<K extends string, V>(obj: Record<K, V>): K[];
-    }
-    namespace message {
-        type BadgeOptions = Twitch.roles[] | Twitch.roles | `${Twitch.roles}/${number}` | `${Twitch.roles}/${number}`[];
-        type TwitchResult = {
-            keys: Twitch.roles[];
-            badges: Twitch.badge[];
-            amount: {
-                [K in Twitch.roles]?: number;
-            };
-        };
-        type YouTubeResult = {
-            isVerified: boolean;
-            isChatOwner: boolean;
-            isChatSponsor: boolean;
-            isChatModerator: boolean;
-        };
-        /**
-         * Finds emotes in a given text.
-         * @param text - The text to search for emotes.
-         * @param emotes - An array of emotes to search for. Defaults to Local data emotes.
-         * @returns An array of emotes found in the text with their positions.
-         */
-        function findEmotesInText(text: string, emotes?: Emote[]): Emote[];
-        /**
-         * Replaces emotes in the text with corresponding HTML image tags.
-         * @param text - The text containing emotes.
-         * @param emotes - An array of emotes with their positions in the text.
-         * @returns The text with emotes replaced by HTML image tags.
-         */
-        function replaceEmotesWithHTML(text: string, emotes: Emote[]): string;
-        /**
-         * Replaces YouTube emotes in the text with corresponding HTML image tags.
-         * @param text - The text containing YouTube emotes.
-         * @param emotes - An array of YouTube emotes. Defaults to Local data YouTube emotes.
-         * @returns The text with YouTube emotes replaced by HTML image tags.
-         */
-        function replaceYoutubeEmotesWithHTML(text: string, emotes?: {
-            emojiId: string;
-            shortcuts: string[];
-            searchTerms: string[];
-            image: {
-                thumbnails: {
-                    url: string;
-                    width: number;
-                    height: number;
-                }[];
-                accessibility: {
-                    accessibilityData: {
-                        label: string;
-                    };
-                };
-            };
-            isCustomEmoji: boolean;
-            index: number;
-        }[]): string;
-        /**
-         * Generates badge data based on the provided badges and platform.
-         * @param badges - The badges to generate. Can be an array or a comma-separated string.
-         * @param provider - The platform provider ('twitch' or 'youtube'). Defaults to 'twitch'.
-         * @returns A promise that resolves to the generated badge data.
-         * @example
-         * ```javascript
-         * // Generate Twitch badges
-         * const twitchBadges = await generateBadges(['broadcaster', 'moderator'], 'twitch');
-         * // Generate YouTube badges
-         * const youtubeBadges = await generateBadges('sponsor, moderator', 'youtube');
-         * ```
-         */
-        function generateBadges<T extends Provider$1>(badges: BadgeOptions | undefined, provider: T): Promise<T extends 'twitch' ? TwitchResult : YouTubeResult>;
-    }
-    namespace event {
-        /**
-         * Parses the provider information from the event detail object.
-         * @param detail - The event detail object received from the StreamElements event.
-         * @returns An object containing the provider and the original event data.
-         */
-        function parseProvider(detail: StreamElements.Event.onEventReceived, _provider?: Provider$1): ClientEvents$1;
-    }
-    namespace string {
-        type Modifier = (value: string, param: string | null | undefined, values: {
-            amount?: number;
-            count?: number;
-        }) => string;
-        const PRESETS: Record<string, string>;
-        /**
-         * Replaces occurrences in a string based on a pattern with the result of an asynchronous callback function.
-         * @param string - The input string to perform replacements on.
-         * @param pattern - The pattern to match in the string (can be a string or a regular expression).
-         * @param callback - An asynchronous callback function that takes the matched substring and any captured groups as arguments and returns the replacement string.
-         * @returns A promise that resolves to the modified string with replacements applied.
-         * @example
-         * ```javascript
-         * const result = await string.replace("Hello World", /World/, async (match) => {
-         *   return await fetchSomeData(match); // Assume this function fetches data asynchronously
-         * });
-         * console.log(result); // Output will depend on the fetched data
-         * ```
-         */
-        function replace(string: string, pattern: string, callback: (match: string, ...groups: string[]) => Promise<string> | string): Promise<string>;
-        /**
-         * Capitalizes the first letter of a given string.
-         * @param string - The input string to be capitalized.
-         * @returns The capitalized string.
-         * @example
-         * ```javascript
-         * const result = string.capitalize("hello world");
-         * console.log(result); // Output: "Hello world"
-         * ```
-         */
-        function capitalize(string: string): Capitalize<string>;
-        /**
-         * Composes a template string by replacing placeholders with corresponding values and applying optional modifiers.
-         * @param template - The template string containing placeholders in the format {key} and optional modifiers in the format [MODIFIER:param=value].
-         * @param values - An object containing key-value pairs to replace the placeholders in the template.
-         * @param options - Optional settings for the composition process.
-         * @returns The composed string with placeholders replaced and modifiers applied.
-         * @example
-         * ```javascript
-         * const { string } = Tixyel.Helper;
-         *
-         * // Basic usage with placeholders and simple modifiers
-         * const template1 = "Hello, {username}! You have {amount} [UPC=messages] and your name is [CAP=name].";
-         * const values1 = { username: "john_doe", amount: 5, name: "john" };
-         * const result1 = string.compose(template1, values1);
-         * // "Hello, john_doe! You have 5 MESSAGES and your name is John."
-         *
-         * // Multiple modifiers in a single block (HTML enabled)
-         * const template2 = "[COLOR:#ff0056,BOLD={username}]";
-         * const values2 = { username: "john_doe" };
-         * const result2 = string.compose(template2, values2, { html: true });
-         * // '<span class="color bold" style="color: #ff0056; font-weight: bold;">john_doe</span>'
-         *
-         * // Conditional rendering with IF (supports ===, >=, &&, ||, !, etc.)
-         * const template3 = "[IF=vip && status === 'live'?VIP Online|Offline]";
-         * const values3 = { status: 'live', vip: true };
-         * const result3 = string.compose(template3, values3);
-         * // "VIP Online"
-         *
-         * // Pluralization using amount / count or an explicit key
-         * const template4 = "You have {amount} [PLURAL=message|messages].";
-         * const values4 = { amount: 1 };
-         * const values5 = { amount: 3 };
-         * const result4a = string.compose(template4, values4); // "You have 1 message."
-         * const result4b = string.compose(template4, values5); // "You have 3 messages."
-         *
-         * // Number formatting
-         * const template5 = "Total: [NUMBER:2=amount] {currency}";
-         * const values6 = { amount: 1234.5, currency: '$' };
-         * const result5 = string.compose(template5, values6);
-         * // e.g. "Total: 1,234.50 $" (locale dependent)
-         *
-         * // Date and time formatting
-         * const template6 = "Created at: [DATE:iso=createdAt] ([DATE:relative=createdAt])";
-         * const values7 = { createdAt: new Date('2020-01-02T03:04:05.000Z') };
-         * const result6 = string.compose(template6, values7);
-         * // e.g. "Created at: 2020-01-02T03:04:05.000Z (Xs ago)"
-         *
-         * // MAP / SWITCH style mapping
-         * const template7 = "Status: [MAP:status=live:Online|offline:Offline|default:Unknown]";
-         * const values8 = { status: 'offline' };
-         * const result7 = string.compose(template7, values8);
-         * // "Status: Offline"
-         *
-         * // Escaping HTML
-         * const template8 = "[ESCAPE={message}]";
-         * const values9 = { message: '<b>Danger & "HTML"</b>' };
-         * const result8 = string.compose(template8, values9);
-         * // "&lt;b&gt;Danger &amp; &quot;HTML&quot;&lt;/b&gt;"
-         *
-         * // Using global presets
-         * Helper.string.PRESETS['alert'] = 'BOLD,COLOR:#ff0056';
-         * const template10 = "[PRESET:alert={username}]";
-         * const values11 = { username: 'john_doe' };
-         * const result10 = string.compose(template10, values11, { html: true });
-         * // '<span class="color bold" style="color: #ff0056; font-weight: bold;">john_doe</span>'
-         * ```
-         */
-        function compose(template: string, values?: Record<string, any>, options?: {
-            method?: 'loop' | 'index';
-            html?: boolean;
-            debug?: boolean;
-            modifiers?: Record<string, Modifier>;
-            aliases?: Record<string, string[]>;
-        }): string;
-    }
-    namespace sound {
-        let playing: boolean;
-        let audio: AudioContext;
-        /**
-         * Play sound from URL with optional volume and replace parameters
-         * @param url - Sound URL to play
-         * @param volume - Volume level from 0 to 100 (default: 100)
-         * @param replace - If true, replaces currently playing sound (default: false)
-         */
-        function play(url: string, volume?: number, replace?: boolean): void;
-    }
-    namespace color {
-        /**
-         * Generate opacity hex value
-         * @param opacity - Opacity value from 0 to 100
-         * @param color - Hex color code
-         * @returns - Hex color code with opacity
-         */
-        function opacity(opacity?: number, color?: string): string;
-        /**
-         * Extract color and opacity from hex code
-         * @param hex - Hex color code
-         * @returns - Object with color and opacity
-         */
-        function extract(hex: string): {
-            color: string;
-            opacity: number;
-        };
-        /**
-         * Validate color string format
-         * @param str - Color string to validate
-         * @returns Detected color format or false if invalid
-         * @example
-         * ```javascript
-         * const format1 = color.validate("#FF5733"); // "hex"
-         * const format2 = color.validate("rgb(255, 87, 51)"); // "rgb"
-         * const format3 = color.validate("hsl(14, 100%, 60%)"); // "hsl"
-         * const format4 = color.validate("orangered"); // "css-color-name"
-         * const format5 = color.validate("invalid-color"); // false
-         * ```
-         */
-        function validate(str: string): false | "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "css-color-name";
-        /**
-         * Convert color to different format
-         * @param str - Color string to convert (e.g. "#FF5733", "rgb(255, 87, 51)")
-         * @param format - Target format
-         * @returns - Converted color string
-         * @example
-         * ```javascript
-         * const hexColor = color.convert("rgb(255, 87, 51)", "hex"); // "#FF5733"
-         * const rgbColor = color.convert("#FF5733", "rgb"); // "rgb(255, 87, 51)"
-         * const hslColor = color.convert("#FF5733", "hsl"); // "hsl(14, 100%, 60%)"
-         * const colorName = color.convert("#FF5733", "css-color-name"); // "orangered"
-         * ```
-         */
-        function convert(str: string, format: 'hex' | 'rgb' | 'rgba' | 'hsl' | 'hsla' | 'css-color-name'): Promise<string | null>;
-    }
-    namespace random {
-        /**
-         * Generate random color
-         * @param type - Color format
-         * @returns - Random color in specified format
-         * @example
-         * ```javascript
-         * const hexColor = random.color('hex');
-         * console.log(hexColor); // e.g. #3e92cc
-         *
-         * const rgbColor = random.color('rgb');
-         * console.log(rgbColor); // e.g. rgb(62, 146, 204)
-         * ```
-         */
-        function color(type?: 'hex' | 'hexa' | 'rgb' | 'rgba' | 'hsl' | 'hsla' | 'css-color-name'): string;
-        /**
-         * Generate random number
-         * @param min - Minimum value
-         * @param max - Maximum value
-         * @param float - Number of decimal places (0 for integer)
-         * @returns - Random number
-         * @example
-         * ```javascript
-         * const intNumber = random.number(1, 10);
-         * console.log(intNumber); // e.g. 7
-         *
-         * const floatNumber = random.number(1, 10, 2);
-         * console.log(floatNumber); // e.g. 3.14
-         * ```
-         */
-        function number(min: number, max: number, float?: number): number;
-        /**
-         * Generate random boolean
-         * @param threshold - Threshold between 0 and 1
-         * @returns - Random boolean
-         * @example
-         * ```javascript
-         * const boolValue = random.boolean(0.7);
-         * console.log(boolValue); // e.g. true (70% chance)
-         * ```
-         */
-        function boolean(threshold?: number): boolean;
-        /**
-         * Generate random string
-         * @param length - Length of the string
-         * @param chars - Characters to use
-         * @returns - Random string
-         * @example
-         * ```javascript
-         * const randString = random.string(10);
-         * console.log(randString); // e.g. "aZ3bT9xYqP"
-         * ```
-         */
-        function string(length: number, chars?: string): string;
-        /**
-         * Pick random element from array
-         * @param arr - Array to pick from
-         * @returns - Random element and its index
-         * @example
-         * ```javascript
-         * const [element, index] = random.array(['apple', 'banana', 'cherry']);
-         * console.log(element, index); // e.g. "banana", 1
-         * ```
-         */
-        function array<T>(arr: T[]): [value: T, index: number];
-        /**
-         * Generate random date
-         * @param start - Start date
-         * @param end - End date
-         * @returns - Random date between start and end
-         * @example
-         * ```javascript
-         * const randDate = random.date(new Date(2020, 0, 1), new Date());
-         * console.log(randDate); // e.g. 2022-05-15T10:30:00.000Z
-         * ```
-         */
-        function date(start?: Date, end?: Date): Date;
-        /**
-         * Generate ISO date string offset by days
-         * @param daysAgo - Number of days to go back
-         * @returns - ISO date string
-         * @example
-         * ```javascript
-         * const isoDate = random.daysOffset(7);
-         * console.log(isoDate); // e.g. "2024-06-10T14:23:45.678Z"
-         *
-         * const isoDate30 = random.daysOffset(30);
-         * console.log(isoDate30); // e.g. "2024-05-18T09:15:30.123Z"
-         * ```
-         */
-        function daysOffset(daysAgo: number): string;
-        /**
-         * Generate UUID v4
-         * @returns - UUID string
-         * @example
-         * ```javascript
-         * const uuid = random.uuid();
-         * console.log(uuid); // e.g. "3b12f1df-5232-4e3a-9a0c-3f9f1b1b1b1b"
-         * ```
-         */
-        function uuid(): string;
-    }
-    namespace fn {
-        /**
-         * Apply function with given thisArg and arguments
-         * @param fn - Function to apply
-         * @param thisArg - Value to use as this when calling fn
-         * @param args - Arguments to pass to fn
-         * @returns Result of calling fn with thisArg and args
-         */
-        function apply<TThis, TArgs extends unknown[], TReturn>(fn: (this: TThis, ...args: TArgs) => TReturn, thisArg: TThis, args: TArgs): TReturn;
-        /**
-         * Call function with given thisArg and arguments
-         * @param fn - Function to call
-         * @param thisArg - Value to use as this when calling fn
-         * @param args - Arguments to pass to fn
-         * @returns Result of calling fn with thisArg and args
-         */
-        function call<TThis, TArgs extends unknown[], TReturn>(fn: (this: TThis, ...args: TArgs) => TReturn, thisArg: TThis, ...args: TArgs): TReturn;
-    }
-    namespace utils {
-        /**
-         * Delays execution for a specified number of milliseconds.
-         * @param ms - The number of milliseconds to delay.
-         * @returns A Promise that resolves after the specified delay.
-         */
-        function delay<R extends any, M extends number>(ms: M, callback?: () => R): Promise<R | null>;
-        /**
-         * Returns typed entries of an object.
-         * @param obj - The object to get entries from.
-         * @returns An array of key-value pairs from the object.
-         */
-        function typedEntries<K extends string, V>(obj: Record<K, V> | Array<V>): [K, V][];
-        /**
-         * Returns typed values of an object.
-         * @param obj - The object to get values from.
-         * @returns An array of values from the object.
-         */
-        function typedValues<K extends string, V>(obj: Record<K, V> | Array<V>): V[];
-        /**
-         * Returns typed keys of an object.
-         * @param obj - The object to get keys from.
-         * @returns An array of keys from the object.
-         */
-        function typedKeys<K extends string, V>(obj: Record<K, V> | Array<V>): K[];
-        /**
-         * Selects an item based on weighted probabilities.
-         * @param items - An object where keys are items and values are their weights.
-         * @returns A randomly selected item based on the given probabilities.
-         */
-        function probability<K extends string, V extends number>(items: Record<K, V>): K | undefined;
-    }
-}
-
-declare namespace Local {
-    type QueueItem = {
-        listener: 'onEventReceived';
-        data: StreamElements.Event.onEventReceived;
-        session?: boolean;
-    } | {
-        listener: 'onWidgetLoad';
-        data: StreamElements.Event.onWidgetLoad;
-    } | {
-        listener: 'onSessionUpdate';
-        data: StreamElements.Event.onSessionUpdate;
-    };
-    const queue: useQueue<QueueItem>;
-    const generate: {
-        session: {
-            types: Record<string, StreamElements.Session.Config.Any>;
-            available(): StreamElements.Session.Config.Available.Data;
-            get(startSession?: StreamElements.Session.Data): Promise<StreamElements.Session.Data>;
-        };
-        event: {
-            /**
-             * Simulates the onWidgetLoad event for a widget.
-             * @param fields - The field values to be included in the event.
-             * @param session - The session data to be included in the event.
-             * @param currency - The currency to be used (default is 'USD').
-             * @returns A Promise that resolves to the simulated onWidgetLoad event data.
-             */
-            onWidgetLoad(fields: Record<string, StreamElements.CustomField.Value>, session: StreamElements.Session.Data, currency?: "BRL" | "USD" | "EUR"): Promise<StreamElements.Event.onWidgetLoad>;
-            /**
-             * Simulates the onSessionUpdate event for a widget.
-             * @param session - The session data to be included in the event.
-             * @returns A Promise that resolves to the simulated onSessionUpdate event data.
-             */
-            onSessionUpdate(session?: StreamElements.Session.Data, update?: ClientEvents$1): Promise<StreamElements.Event.onSessionUpdate>;
-            /**
-             * Simulates the onEventReceived event for a widget.
-             * @param provider - The provider of the event (default is 'random').
-             * @param type - The type of event to simulate (default is 'random').
-             * @param options - Additional options to customize the event data.
-             * @returns A Promise that resolves to the simulated onEventReceived event data, or null if the event type is not supported.
-             * @example
-             * ```javascript
-             * // Simulate a random event
-             * const randomEvent = await Local .generate.event.onEventReceived();
-             *
-             * // Simulate a Twitch message event with custom options
-             * const twitchMessageEvent = await Local .generate.event.onEventReceived('twitch', 'message', { name: 'Streamer', message: 'Hello World!' });
-             * ```
-             */
-            onEventReceived(provider?: Provider$1 | "random", type?: StreamElements.Event.onEventReceived["listener"] | "random" | "tip" | "cheer" | "follower" | "raid" | "subscriber", options?: Record<string, string | number | boolean>): Promise<StreamElements.Event.onEventReceived | null>;
+            onEventReceived(provider?: Provider$1 | "random", type?: StreamElements.Event.onEventReceived["listener"] | "random" | "tip" | "cheer" | "follower" | "raid" | "subscriber", options?: Record<string, string | number | boolean>): Promise<StreamElements.Event.onEventReceived | null>;
         };
     };
     const emulate: {
@@ -2768,7 +2242,7 @@ declare namespace Local {
             message(data?: Partial<{
                 name: string;
                 message: string;
-                badges: Helper.message.BadgeOptions;
+                badges: BadgeOptions;
                 color: string;
                 userId: string;
                 msgId: string;
@@ -2828,7 +2302,7 @@ declare namespace Local {
             message(data?: Partial<{
                 name: string;
                 message: string;
-                badges: Helper.message.BadgeOptions;
+                badges: BadgeOptions;
                 color: string;
                 userId: string;
                 msgId: string;
@@ -2864,6 +2338,568 @@ declare namespace Local {
     function start(fieldsFile?: string[], dataFiles?: string[], session?: StreamElements.Session.Data): Promise<void>;
 }
 
+/**
+ * NumberHelper class provides utility methods for working with numbers, including translation to words, balancing within a range, rounding, and generating random numbers.
+ */
+declare class NumberHelper {
+    /**
+     * Translate number to words
+     * @param num - Number to translate
+     * @param type - Translation type
+     * @returns - Number in words
+     * @example
+     * ```javascript
+     * const cardinal = translate(42, 'cardinal');
+     * console.log(cardinal); // "forty-two"
+     * const ordinal = translate(42, 'ordinal');
+     * console.log(ordinal); // "forty-second"
+     * const suffix = translate(42, 'suffix');
+     * console.log(suffix); // "42nd"
+     * ```
+     */
+    translate(num: number, type?: 'cardinal' | 'ordinal' | 'suffix'): string;
+    /**
+     * Balances a number within a specified range
+     * @param amount - Number to balance
+     * @param min - Minimum value
+     * @param max - Maximum value
+     * @param decimals - Number of decimal places to round to (default is 0)
+     * @returns - Balanced number
+     * @example
+     * ```javascript
+     * const balancedValue = balance(150, 0, 100);
+     * console.log(balancedValue); // 100
+     * ```
+     */
+    balance(amount: number, min?: number, max?: number, decimals?: number): number;
+    /**
+     * Rounds a number to a specified number of decimal places
+     * @param value - Number to round
+     * @param decimals - Number of decimal places (default is 2)
+     * @returns Rounded number
+     * @example
+     * ```javascript
+     * const roundedValue = round(3.14159, 3);
+     * console.log(roundedValue); // 3.142
+     * const roundedValueDefault = round(3.14159);
+     * console.log(roundedValueDefault); // 3.14
+     * const roundedValueZero = round(3.14159, 0);
+     * console.log(roundedValueZero); // 3
+     * ```
+     */
+    round(value: number, decimals?: number): number;
+    /**
+     * Generate random number
+     * @param min - Minimum value
+     * @param max - Maximum value
+     * @param float - Number of decimal places (0 for integer)
+     * @returns - Random number
+     * @example
+     * ```javascript
+     * const intNumber = random(1, 10);
+     * console.log(intNumber); // e.g. 7
+     *
+     * const floatNumber = random(1, 10, 2);
+     * console.log(floatNumber); // e.g. 3.14
+     * ```
+     */
+    random(min: number, max: number, float?: number): number;
+}
+
+interface ScaleOptions<T extends HTMLElement> {
+    /**
+     * The parent element to use for scaling calculations. If not provided, the element's parent will be used.
+     */
+    parent?: HTMLElement;
+    /**
+     * The preferred dimension to base the scaling on. Can be 'width', 'height', or 'auto' (default).
+     */
+    prefer?: 'width' | 'height' | 'auto';
+    /**
+     * The minimum percentage of the parent size to scale to. Default is 0.
+     */
+    min?: number;
+    /**
+     * The maximum percentage of the parent size to scale to. Default is 1 (100%).
+     */
+    max?: number;
+    /**
+     * A callback function that is called after scaling is applied.
+     * @param this - The HTML element being scaled.
+     * @param number - The scale factor applied to the element.
+     * @param element - The HTML element being scaled.
+     * @returns void
+     */
+    apply?: (this: T, number: number, element: T) => void;
+}
+type FitTextOptions = {
+    minFontSize?: number;
+    maxFontSize?: number;
+    parent?: HTMLElement;
+};
+declare class ElementHelper {
+    /**
+     * Merges outer span styles with inner span styles in the provided HTML string.
+     * @param outerStyle - The style string to be applied to the outer span.
+     * @param innerHTML - The inner HTML string which may contain a span with its own styles.
+     * @returns A new HTML string with merged styles applied to a single span.
+     * @example
+     * ```javascript
+     * const result = mergeSpanStyles("color: red; font-weight: bold;", '<span style="font-size: 14px;">Hello World</span>');
+     * console.log(result); // Output: '<span style="font-size: 14px; color: red; font-weight: bold;">Hello World</span>'
+     * ```
+     */
+    mergeSpanStyles(outerStyle: string, innerHTML: string, className?: string): string;
+    /**
+     * Scales an HTML element to fit within its parent element based on specified minimum and maximum scale factors.
+     * @param element - The HTML element to be scaled.
+     * @param min - Minimum scale factor (default is 0).
+     * @param max - Maximum scale factor (default is 1).
+     * @param options - Optional settings for scaling.
+     * @returns - An object containing the new width, height, and scale factor, or void if not applied.
+     * @example
+     * ```javascript
+     * const element = document.getElementById('myElement');
+     * scale(element, 0.5, 1, { return: false });
+     * ```
+     */
+    scale(element: HTMLElement, min?: number, max?: number, options?: {
+        return: boolean;
+        parent: HTMLElement;
+        base: 'width' | 'height';
+    }): {
+        width: number;
+        height: number;
+        scale: number;
+    } | void;
+    /**
+     * Scales an HTML element to fit within its parent element based on specified options.
+     * @param element - The HTML element to be scaled.
+     * @param options - Optional settings for scaling.
+     * @returns The scale factor applied to the element.
+     * @example
+     * ```javascript
+     * const element = document.getElementById('myElement');
+     * const scaleFactor  scalev2(element, {
+     *   min: 0.5,
+     *   max: 1,
+     *   prefer: 'width',
+     *   apply: (scale, el) => el.style.transform = `scale(${scale})`
+     * });
+     * console.log(`Element scaled by a factor of ${scaleFactor}`);
+     * ```
+     */
+    scalev2<T extends HTMLElement>(element: T, options?: ScaleOptions<T>): number;
+    /**
+     * Fits the text within the parent element by adjusting the font size.
+     * @param element - The HTML element containing the text to be fitted.
+     * @param compressor - A multiplier to adjust the fitting sensitivity (default is 1).
+     * @param options - Optional settings for fitting text.
+     * @returns The HTML element with adjusted font size.
+     * @example
+     * ```javascript
+     * const element = document.getElementById('myTextElement');
+     * fitText(element, 1, { minFontSize: 12, maxFontSize: 36 });
+     * console.log(`Adjusted font size: ${element.style.fontSize}`);
+     * ```
+     */
+    fitText(element: HTMLElement, compressor?: number, options?: FitTextOptions): HTMLElement;
+    /**
+     * Wraps formatted HTML text with containers and splits characters into indexed spans.
+     * Adds 'container' class and data-index to all parent elements, and wraps each character in a span with class 'char' and data-index.
+     * @param htmlString - The input HTML string containing formatted text elements (span, strong, em, etc).
+     * @param startIndex - The starting index for the data-index attribute (default is 0).
+     * @returns - A new HTML string with containers and character-level indexing.
+     * @example
+     * ```javascript
+     * const result = splitTextToChars('<span>TesTe</span> <strong>bold</strong>', 0);
+     * console.log(result);
+     * // Output: '<span class="container" data-index="0"><span class="char" data-index="0">T</span><span class="char" data-index="1">e</span>...'
+     * ```
+     */
+    splitTextToChars(htmlString: string, startIndex?: number, preserveInterElementWhitespace?: boolean): string;
+}
+
+declare class ObjectHelper {
+    /**
+     * Flattens a nested object into a single-level object with dot-separated keys.
+     * @param obj - The nested object to be flattened.
+     * @param prefix  - The prefix to be added to each key (used for recursion).
+     * @returns A flattened object with dot-separated keys.
+     * @example
+     * ```javascript
+     * const nestedObj = { a: { b: 1, c: { d: 2 } }, e: [3, 4] };
+     * const flatObj = flatten(nestedObj);
+     * console.log(flatObj);
+     * // Output: { 'a.b': '1', 'a.c.d': '2', 'e:0': '3', 'e:1': '4' }
+     * ```
+     */
+    flatten(obj: Record<string, any>, stringify?: boolean, prefix?: string): Record<string, typeof stringify extends true ? string : string | number | boolean>;
+    /**
+     * Returns the entries of an object as an array of key-value pairs, with proper typing.
+     * @param obj - The object to retrieve entries from.
+     * @returns An array of key-value pairs from the object, typed as an array of tuples with key and value types.
+     */
+    entries<K extends string, V>(obj: Record<K, V>): [K, V][];
+    /**
+     * Returns the values of an object as an array, with proper typing.
+     * @param obj - The object to retrieve values from.
+     * @returns An array of values from the object, typed as an array of the value type.
+     */
+    values<K extends string, V>(obj: Record<K, V>): V[];
+    /**
+     * Returns the keys of an object as an array of strings, with proper typing.
+     * @param obj - The object to retrieve keys from.
+     * @returns An array of keys from the object, typed as an array of strings.
+     */
+    keys<K extends string, V>(obj: Record<K, V>): K[];
+}
+
+declare class RandomHelper {
+    /**
+     * Generate random color
+     * @param type - Color format
+     * @returns - Random color in specified format
+     * @example
+     * ```javascript
+     * const hexColor = random.color('hex');
+     * console.log(hexColor); // e.g. #3e92cc
+     *
+     * const rgbColor = random.color('rgb');
+     * console.log(rgbColor); // e.g. rgb(62, 146, 204)
+     * ```
+     */
+    color(type?: 'hex' | 'hexa' | 'rgb' | 'rgba' | 'hsl' | 'hsla' | 'css-color-name'): string;
+    /**
+     * Generate random number
+     * @param min - Minimum value
+     * @param max - Maximum value
+     * @param float - Number of decimal places (0 for integer)
+     * @returns - Random number
+     * @example
+     * ```javascript
+     * const intNumber = random.number(1, 10);
+     * console.log(intNumber); // e.g. 7
+     *
+     * const floatNumber = random.number(1, 10, 2);
+     * console.log(floatNumber); // e.g. 3.14
+     * ```
+     */
+    number(min: number, max: number, float?: number): number;
+    /**
+     * Generate random boolean
+     * @param threshold - Threshold between 0 and 1
+     * @returns - Random boolean
+     * @example
+     * ```javascript
+     * const boolValue = random.boolean(0.7);
+     * console.log(boolValue); // e.g. true (70% chance)
+     * ```
+     */
+    boolean(threshold?: number): boolean;
+    /**
+     * Generate random string
+     * @param length - Length of the string
+     * @param chars - Characters to use
+     * @returns - Random string
+     * @example
+     * ```javascript
+     * const randString = random.string(10);
+     * console.log(randString); // e.g. "aZ3bT9xYqP"
+     * ```
+     */
+    string(length: number, chars?: string): string;
+    /**
+     * Pick random element from array
+     * @param arr - Array to pick from
+     * @returns - Random element and its index
+     * @example
+     * ```javascript
+     * const [element, index] = random.array(['apple', 'banana', 'cherry']);
+     * console.log(element, index); // e.g. "banana", 1
+     * ```
+     */
+    array<T>(arr: T[]): [value: T, index: number];
+    /**
+     * Generate random date
+     * @param start - Start date
+     * @param end - End date
+     * @returns - Random date between start and end
+     * @example
+     * ```javascript
+     * const randDate = random.date(new Date(2020, 0, 1), new Date());
+     * console.log(randDate); // e.g. 2022-05-15T10:30:00.000Z
+     * ```
+     */
+    date(start?: Date, end?: Date): Date;
+    /**
+     * Generate ISO date string offset by days
+     * @param daysAgo - Number of days to go back
+     * @returns - ISO date string
+     * @example
+     * ```javascript
+     * const isoDate = random.daysOffset(7);
+     * console.log(isoDate); // e.g. "2024-06-10T14:23:45.678Z"
+     *
+     * const isoDate30 = random.daysOffset(30);
+     * console.log(isoDate30); // e.g. "2024-05-18T09:15:30.123Z"
+     * ```
+     */
+    daysOffset(daysAgo: number): string;
+    /**
+     * Generate UUID v4
+     * @returns - UUID string
+     * @example
+     * ```javascript
+     * const uuid = random.uuid();
+     * console.log(uuid); // e.g. "3b12f1df-5232-4e3a-9a0c-3f9f1b1b1b1b"
+     * ```
+     */
+    uuid(): string;
+}
+
+declare class EventHelper {
+    /**
+     * Parses the provider information from the event detail object.
+     * @param detail - The event detail object received from the StreamElements event.
+     * @returns An object containing the provider and the original event data.
+     */
+    parseProvider(detail: StreamElements.Event.onEventReceived, _provider?: Provider$1): ClientEvents$1;
+}
+
+type Modifier = (value: string, param: string | null | undefined, values: {
+    amount?: number;
+    count?: number;
+}) => string;
+declare class StringHelper {
+    /**
+     * Replaces occurrences in a string based on a pattern with the result of an asynchronous callback function.
+     * @param string - The input string to perform replacements on.
+     * @param pattern - The pattern to match in the string (can be a string or a regular expression).
+     * @param callback - An asynchronous callback function that takes the matched substring and any captured groups as arguments and returns the replacement string.
+     * @returns A promise that resolves to the modified string with replacements applied.
+     * @example
+     * ```javascript
+     * const result = await string.replace("Hello World", /World/, async (match) => {
+     *   return await fetchSomeData(match); // Assume this function fetches data asynchronously
+     * });
+     * console.log(result); // Output will depend on the fetched data
+     * ```
+     */
+    replace(string: string, pattern: string, callback: (match: string, ...groups: string[]) => Promise<string> | string): Promise<string>;
+    /**
+     * Capitalizes the first letter of a given string.
+     * @param string - The input string to be capitalized.
+     * @returns The capitalized string.
+     * @example
+     * ```javascript
+     * const result = string.capitalize("hello world");
+     * console.log(result); // Output: "Hello world"
+     * ```
+     */
+    capitalize(string: string): Capitalize<string>;
+    PRESETS: Record<string, string>;
+    /**
+     * Composes a template string by replacing placeholders with corresponding values and applying optional modifiers.
+     * @param template - The template string containing placeholders in the format {key} and optional modifiers in the format [MODIFIER:param=value].
+     * @param values - An object containing key-value pairs to replace the placeholders in the template.
+     * @param options - Optional settings for the composition process.
+     * @returns The composed string with placeholders replaced and modifiers applied.
+     * @example
+     * ```javascript
+     * const { string } = Tixyel.Helper;
+     *
+     * // Basic usage with placeholders and simple modifiers
+     * const template1 = "Hello, {username}! You have {amount} [UPC=messages] and your name is [CAP=name].";
+     * const values1 = { username: "john_doe", amount: 5, name: "john" };
+     * const result1 = string.compose(template1, values1);
+     * // "Hello, john_doe! You have 5 MESSAGES and your name is John."
+     *
+     * // Multiple modifiers in a single block (HTML enabled)
+     * const template2 = "[COLOR:#ff0056,BOLD={username}]";
+     * const values2 = { username: "john_doe" };
+     * const result2 = string.compose(template2, values2, { html: true });
+     * // '<span class="color bold" style="color: #ff0056; font-weight: bold;">john_doe</span>'
+     *
+     * // Conditional rendering with IF (supports ===, >=, &&, ||, !, etc.)
+     * const template3 = "[IF=vip && status === 'live'?VIP Online|Offline]";
+     * const values3 = { status: 'live', vip: true };
+     * const result3 = string.compose(template3, values3);
+     * // "VIP Online"
+     *
+     * // Pluralization using amount / count or an explicit key
+     * const template4 = "You have {amount} [PLURAL=message|messages].";
+     * const values4 = { amount: 1 };
+     * const values5 = { amount: 3 };
+     * const result4a = string.compose(template4, values4); // "You have 1 message."
+     * const result4b = string.compose(template4, values5); // "You have 3 messages."
+     *
+     * // Number formatting
+     * const template5 = "Total: [NUMBER:2=amount] {currency}";
+     * const values6 = { amount: 1234.5, currency: '$' };
+     * const result5 = string.compose(template5, values6);
+     * // e.g. "Total: 1,234.50 $" (locale dependent)
+     *
+     * // Date and time formatting
+     * const template6 = "Created at: [DATE:iso=createdAt] ([DATE:relative=createdAt])";
+     * const values7 = { createdAt: new Date('2020-01-02T03:04:05.000Z') };
+     * const result6 = string.compose(template6, values7);
+     * // e.g. "Created at: 2020-01-02T03:04:05.000Z (Xs ago)"
+     *
+     * // MAP / SWITCH style mapping
+     * const template7 = "Status: [MAP:status=live:Online|offline:Offline|default:Unknown]";
+     * const values8 = { status: 'offline' };
+     * const result7 = string.compose(template7, values8);
+     * // "Status: Offline"
+     *
+     * // Escaping HTML
+     * const template8 = "[ESCAPE={message}]";
+     * const values9 = { message: '<b>Danger & "HTML"</b>' };
+     * const result8 = string.compose(template8, values9);
+     * // "&lt;b&gt;Danger &amp; &quot;HTML&quot;&lt;/b&gt;"
+     *
+     * // Using global presets
+     * Helper.string.PRESETS['alert'] = 'BOLD,COLOR:#ff0056';
+     * const template10 = "[PRESET:alert={username}]";
+     * const values11 = { username: 'john_doe' };
+     * const result10 = string.compose(template10, values11, { html: true });
+     * // '<span class="color bold" style="color: #ff0056; font-weight: bold;">john_doe</span>'
+     * ```
+     */
+    compose(template: string, values?: Record<string, any>, options?: {
+        method?: 'loop' | 'index';
+        html?: boolean;
+        debug?: boolean;
+        modifiers?: Record<string, Modifier>;
+        aliases?: Record<string, string[]>;
+    }): string;
+}
+
+declare class ColorHelper {
+    /**
+     * Generate opacity hex value
+     * @param opacity - Opacity value from 0 to 100
+     * @param color - Hex color code
+     * @returns - Hex color code with opacity
+     */
+    opacity(opacity?: number, color?: string): string;
+    /**
+     * Extract color and opacity from hex code
+     * @param hex - Hex color code
+     * @returns - Object with color and opacity
+     */
+    extract(hex: string): {
+        color: string;
+        opacity: number;
+    };
+    /**
+     * Validate color string format
+     * @param str - Color string to validate
+     * @returns Detected color format or false if invalid
+     * @example
+     * ```javascript
+     * const format1 = color.validate("#FF5733"); // "hex"
+     * const format2 = color.validate("rgb(255, 87, 51)"); // "rgb"
+     * const format3 = color.validate("hsl(14, 100%, 60%)"); // "hsl"
+     * const format4 = color.validate("orangered"); // "css-color-name"
+     * const format5 = color.validate("invalid-color"); // false
+     * ```
+     */
+    validate(str: string): false | "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "css-color-name";
+    /**
+     * Convert color to different format
+     * @param str - Color string to convert (e.g. "#FF5733", "rgb(255, 87, 51)")
+     * @param format - Target format
+     * @returns - Converted color string
+     * @example
+     * ```javascript
+     * const hexColor = color.convert("rgb(255, 87, 51)", "hex"); // "#FF5733"
+     * const rgbColor = color.convert("#FF5733", "rgb"); // "rgb(255, 87, 51)"
+     * const hslColor = color.convert("#FF5733", "hsl"); // "hsl(14, 100%, 60%)"
+     * const colorName = color.convert("#FF5733", "css-color-name"); // "orangered"
+     * ```
+     */
+    convert(str: string, format: 'hex' | 'rgb' | 'rgba' | 'hsl' | 'hsla' | 'css-color-name'): Promise<string | null>;
+}
+
+declare class SoundHelper {
+    playing: boolean;
+    audio: AudioContext;
+    /**
+     * Play sound from URL with optional volume and replace parameters
+     * @param url - Sound URL to play
+     * @param volume - Volume level from 0 to 100 (default: 100)
+     * @param replace - If true, replaces currently playing sound (default: false)
+     */
+    play(url: string, volume?: number, replace?: boolean): void;
+}
+
+declare class FunctionHelper {
+    /**
+     * Apply function with given thisArg and arguments
+     * @param fn - Function to apply
+     * @param thisArg - Value to use as this when calling fn
+     * @param args - Arguments to pass to fn
+     * @returns Result of calling fn with thisArg and args
+     */
+    apply<TThis, TArgs extends unknown[], TReturn>(fn: (this: TThis, ...args: TArgs) => TReturn, thisArg: TThis, args: TArgs): TReturn;
+    /**
+     * Call function with given thisArg and arguments
+     * @param fn - Function to call
+     * @param thisArg - Value to use as this when calling fn
+     * @param args - Arguments to pass to fn
+     * @returns Result of calling fn with thisArg and args
+     */
+    call<TThis, TArgs extends unknown[], TReturn>(fn: (this: TThis, ...args: TArgs) => TReturn, thisArg: TThis, ...args: TArgs): TReturn;
+}
+
+declare class UtilsHelper {
+    /**
+     * Delays execution for a specified number of milliseconds.
+     * @param ms - The number of milliseconds to delay.
+     * @returns A Promise that resolves after the specified delay.
+     */
+    delay<R extends any, M extends number>(ms: M, callback?: () => R): Promise<R | null>;
+    /**
+     * Returns typed entries of an object.
+     * @param obj - The object to get entries from.
+     * @returns An array of key-value pairs from the object.
+     */
+    typedEntries<K extends string, V>(obj: Record<K, V> | Array<V>): [K, V][];
+    /**
+     * Returns typed values of an object.
+     * @param obj - The object to get values from.
+     * @returns An array of values from the object.
+     */
+    typedValues<K extends string, V>(obj: Record<K, V> | Array<V>): V[];
+    /**
+     * Returns typed keys of an object.
+     * @param obj - The object to get keys from.
+     * @returns An array of keys from the object.
+     */
+    typedKeys<K extends string, V>(obj: Record<K, V> | Array<V>): K[];
+    /**
+     * Selects an item based on weighted probabilities.
+     * @param items - An object where keys are items and values are their weights.
+     * @returns A randomly selected item based on the given probabilities.
+     */
+    probability<K extends string, V extends number>(items: Record<K, V>): K | undefined;
+}
+
+declare namespace Helper {
+    const number: NumberHelper;
+    const element: ElementHelper;
+    const object: ObjectHelper;
+    const message: MessageHelper;
+    const event: EventHelper;
+    const string: StringHelper;
+    const sound: SoundHelper;
+    const color: ColorHelper;
+    const random: RandomHelper;
+    const fn: FunctionHelper;
+    const utils: UtilsHelper;
+}
+
 declare namespace Data {
     const avatars: string[];
     const badges: Record<Twitch.roles, Twitch.badge>;
@@ -2996,4 +3032,4 @@ declare global {
 }
 
 export { Alejo, Button, Command, EventProvider, StreamElements, StreamElementsEvents, Twitch, TwitchEvents, YoutubeEvents, main as default, useComfyJs, useLogger, useQueue, useStorage };
-export type { BttvEmote, ClientEvents$1 as ClientEvents, Emote, Provider$1 as Provider, SeventvEmote, TwitchEmote };
+export type { BttvEmote, ClientEvents$1 as ClientEvents, Emoji, Emote, Provider$1 as Provider, SeventvEmote, TwitchEmote };