@tixyel/streamelements 5.3.0 → 5.4.0

package/dist/index.d.ts

@@ -1621,6 +1621,7 @@ type BttvEmote = {
         height: number;
     };
 };
+type Emote = TwitchEmote | BttvEmote | SeventvEmote;
 
 interface ButtonOptions {
     field: string | ((field: string, value: string | boolean | number) => boolean);
@@ -1967,8 +1968,493 @@ declare class useQueue<T> extends EventProvider<QueueEvents<T>> {
     on<K extends keyof QueueEvents<T>>(eventName: K, callback: (this: useQueue<T>, ...args: QueueEvents<T>[K]) => void): this;
 }
 
-type Emote = TwitchEmote | BttvEmote | SeventvEmote;
-type BadgeOptions = Twitch.roles[] | Twitch.roles | `${Twitch.roles}, ${Twitch.roles}` | `${Twitch.roles}, ${Twitch.roles}, ${Twitch.roles}`;
+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
+         * @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): 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.float(3.14159, 3);
+         * console.log(roundedValue); // 3.142
+         * ```
+         */
+        function round(value: number, decimals?: number): number;
+    }
+    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;
+    }
+    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';
+            /**
+             * 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;
+        };
+        /**
+         * 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): 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>;
+    }
+    namespace message {
+        type BadgeOptions = Twitch.roles[] | Twitch.roles | `${Twitch.roles}, ${Twitch.roles}` | `${Twitch.roles}, ${Twitch.roles}, ${Twitch.roles}`;
+        type TwitchResult = {
+            keys: Twitch.roles[];
+            badges: Twitch.badge[];
+        };
+        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): ClientEvents$1;
+    }
+    namespace string {
+        type Modifier = (value: string, param: string | null | undefined, values: {
+            amount?: number;
+            count?: number;
+        }) => 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 template = "Hello, {username}! You have {amount} [UPPERCASE=messages] and your name is [CAPITALIZE=name].";
+         * const values = { username: "john_doe", amount: 5, name: "john" };
+         * const result = string.compose(template, values);
+         * console.log(result); // Output: "Hello, john_doe! You have 5 MESSAGES and your name is John."
+         * ```
+         */
+        function compose(template: string, values?: Record<string, any>, options?: {
+            method?: 'loop' | 'index';
+            html?: 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;
+    }
+}
 
 declare namespace Local {
     type Queue = useQueue<{
@@ -2027,7 +2513,7 @@ declare namespace Local {
             message(data?: Partial<{
                 name: string;
                 message: string;
-                badges: BadgeOptions;
+                badges: Helper.message.BadgeOptions;
                 color: string;
                 userId: string;
                 msgId: string;
@@ -2074,7 +2560,7 @@ declare namespace Local {
             message(data?: Partial<{
                 name: string;
                 message: string;
-                badges: BadgeOptions;
+                badges: Helper.message.BadgeOptions;
                 color: string;
                 userId: string;
                 msgId: string;
@@ -2203,144 +2689,6 @@ declare class useLogger {
     readonly simple: LogMethod;
 }
 
-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 namespace Helper {
-    const sound: {
-        playing: boolean;
-        audio: AudioContext | null;
-        play(url: string, volume?: number, replace?: boolean): void;
-    };
-    const element: {
-        mergeSpanStyles(outerStyle: string, innerHTML: string, className?: string): string;
-        scale(element: HTMLElement, min?: number, max?: number, options?: {
-            return: boolean;
-            parent: HTMLElement;
-            base: "width" | "height";
-        }): {
-            width: number;
-            height: number;
-            scale: number;
-        } | void;
-        scalev2<T extends HTMLElement>(element: T, options?: ScaleOptions<T>): number;
-        fitText(element: HTMLElement, compressor?: number, options?: FitTextOptions): HTMLElement;
-        splitTextToChars(htmlString: string, startIndex?: number): string;
-    };
-    const color: {
-        opacity(opacity?: number, color?: string): string;
-        extract(hex: string): {
-            color: string;
-            opacity: number;
-        };
-        validate(str: string): false | "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "css-color-name";
-        convert(str: string, format: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "css-color-name"): Promise<string | null>;
-        random: (type?: "hex" | "hexa" | "rgb" | "rgba" | "hsl" | "hsla" | "css-color-name") => string;
-    };
-    const object: {
-        flatten(obj: Record<string, any>, stringify?: boolean, prefix?: string): Record<string, typeof stringify extends true ? string : string | number | boolean>;
-    };
-    const utils: {
-        delay<R extends unknown, M extends number>(ms: M, callback?: () => R): Promise<R | null>;
-        typedEntries<K extends string, V>(obj: Record<K, V> | Array<V>): [K, V][];
-        typedValues<K extends string, V>(obj: Record<K, V> | Array<V>): V[];
-        typedKeys<K extends string, V>(obj: Record<K, V> | Array<V>): K[];
-        probability<K extends string, V extends number>(items: Record<K, V>): K | undefined;
-    };
-    const random: {
-        color(type?: "hex" | "hexa" | "rgb" | "rgba" | "hsl" | "hsla" | "css-color-name"): string;
-        number(min: number, max: number, float?: number): number;
-        boolean(threshold?: number): boolean;
-        string(length: number, chars?: string): string;
-        array<T>(arr: T[]): [value: T, index: number];
-        date(start?: Date, end?: Date): Date;
-        daysOffset(daysAgo: number): string;
-        uuid(): string;
-    };
-    const number: {
-        translate(num: number, type?: "cardinal" | "ordinal" | "suffix"): string;
-        balance(amount: number, min?: number, max?: number): number;
-        round(value: number, decimals?: number): number;
-    };
-    const string: {
-        replace(string: string, pattern: string, callback: (match: string, ...groups: string[]) => Promise<string> | string): Promise<string>;
-        capitalize(string: string): Capitalize<string>;
-        compose(template: string, values?: Record<string, any>, options?: {
-            method?: "loop" | "index";
-            html?: boolean;
-            modifiers?: Record<string, (value: string, param: string | null | undefined, values: {
-                amount?: number;
-                count?: number;
-            }) => string>;
-            aliases?: Record<string, string[]>;
-        }): string;
-    };
-    const message: {
-        findEmotesInText(text: string, emotes?: Emote[]): Emote[];
-        replaceEmotesWithHTML(text: string, emotes: Emote[]): string;
-        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;
-        generateBadges<T extends Provider$1>(badges: BadgeOptions | undefined, provider: T): Promise<T extends "twitch" ? {
-            keys: Twitch.roles[];
-            badges: Twitch.badge[];
-        } : {
-            isVerified: boolean;
-            isChatOwner: boolean;
-            isChatSponsor: boolean;
-            isChatModerator: boolean;
-        }>;
-    };
-    const event: {
-        parseProvider(detail: StreamElements.Event.onEventReceived): ClientEvents$1;
-    };
-}
-
 declare namespace Data {
     const avatars: string[];
     const badges: Record<Twitch.roles, Twitch.badge>;
@@ -2417,4 +2765,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, Provider$1 as Provider, SeventvEmote, TwitchEmote };
+export type { BttvEmote, ClientEvents$1 as ClientEvents, Emote, Provider$1 as Provider, SeventvEmote, TwitchEmote };