@tixyel/streamelements 5.2.0 → 5.4.0

package/dist/index.d.ts

@@ -6,243 +6,6 @@
 
 import { ComfyJSInstance, OnErrorHandler, OnCommandHandler, OnChatHandler, OnWhisperHandler, OnMessageDeletedHandler, OnJoinHandler, OnPartHandler, OnHostedHandler, OnRaidHandler, OnSubHandler, OnResubHandler, OnSubGiftHandler, OnSubMysteryGiftHandler, OnGiftSubContinueHandler, OnCheerHandler, OnChatModeHandler, OnRewardHandler, OnConnectedHandler, OnReconnectHandler } from 'comfy.js';
 
-interface ButtonOptions {
-    field: string | ((field: string, value: string | boolean | number) => boolean);
-    template?: string;
-    run: (field: string, value: string | boolean | number) => void;
-}
-declare class Button {
-    field: ButtonOptions['field'];
-    template: string;
-    run: ButtonOptions['run'];
-    constructor(options: ButtonOptions);
-    parse(field: string, value: string | boolean | number): Button;
-    remove(): void;
-    static execute(field: string, value: string | boolean | number): boolean;
-}
-
-type Provider$1 = 'twitch' | 'youtube' | 'kick' | 'facebook' | 'streamelements';
-type ClientEvents$1 = {
-    provider: 'streamelements';
-    data: StreamElements.Event.Provider.StreamElements.Events;
-} | {
-    provider: 'twitch';
-    data: StreamElements.Event.Provider.Twitch.Events;
-} | {
-    provider: 'youtube';
-    data: StreamElements.Event.Provider.YouTube.Events;
-} | {
-    provider: 'kick';
-    data: StreamElements.Event.Provider.Kick.Events;
-} | {
-    provider: 'facebook';
-    data: StreamElements.Event.Provider.Facebook.Events;
-};
-
-declare namespace StreamElementsEvents {
-    namespace Tip {
-        type Data = {
-            listener: 'tip-latest';
-            event: Event;
-        };
-        type Event = {
-            amount: number;
-            avatar: string;
-            name: string;
-            displayName: string;
-            providerId: string;
-            _id: string;
-            sessionTop: boolean;
-            type: 'tip';
-            originalEventName: 'tip-latest';
-        };
-    }
-    namespace KVStore {
-        type Data = {
-            listener: 'kvstore:update';
-            event: Event;
-        };
-        type Event = {
-            data: {
-                key: `customWidget.${string}`;
-                value: string | number | boolean | Record<string, any>;
-            };
-        };
-    }
-    namespace BotCounter {
-        type Data = {
-            listener: 'bot:counter';
-            event: Event;
-        };
-        type Event = {
-            counter: string;
-            value: number;
-        };
-    }
-    namespace AlertService {
-        type Data = {
-            listener: 'alertService:toggleSound';
-            event: Event;
-        };
-        type Event = {
-            muted: boolean;
-        };
-    }
-    namespace EventSkip {
-        type Data = {
-            listener: 'event:skip';
-            event: Event;
-        };
-        type Event = {};
-    }
-    namespace EventTest {
-        export type Data = {
-            listener: 'event:test';
-            event: Event;
-        };
-        export type Event = widgetButton | emulatedEvents<EventType> | Session;
-        type items = {
-            name: string;
-            price: number;
-            quantity: number;
-        };
-        type widgetButton = {
-            listener: 'widget-button';
-            field: string;
-            value: string | number | boolean;
-        };
-        type EventType = 'follower' | 'subscriber' | 'tip' | 'cheer' | 'raid';
-        type EventTier = 'prime' | '1000' | '2000' | '3000';
-        type emulatedEvents<T extends EventType> = {
-            listener: `${T}-latest`;
-            event: {
-                type: T;
-                name: string;
-                amount: number;
-                count: number;
-                message?: string;
-                gifted?: boolean;
-                bulkGifted?: boolean;
-                sender?: string;
-                subExtension?: boolean;
-                items: items[];
-                tier: EventTier;
-                month: string;
-                isTest: true;
-            };
-        };
-        type Session = SessionCount | SessionTotal | SessionTop | SessionGoal | SessionRecent | SessionPoints;
-        type SessionCount = {
-            listener: `${EventType}-count`;
-            event: {
-                type: EventType;
-                name: string;
-                count: number;
-                items: items[];
-                tier: EventTier;
-                month: string;
-                isTest: true;
-            };
-        };
-        type SessionTotal = {
-            listener: `${EventType}-total`;
-            event: {
-                type: EventType;
-                name: string;
-                amount: number;
-                count: number;
-                items: items[];
-                tier: EventTier;
-                month: string;
-                isTest: true;
-            };
-        };
-        type SessionTop = {
-            listener: `${EventType}-top`;
-            event: {
-                type: EventType;
-                name: string;
-                amount: number;
-                count: number;
-                items: items[];
-                tier: EventTier;
-                month: string;
-                isTest: true;
-            };
-        };
-        type SessionGoal = {
-            listener: `${EventType}-goal`;
-            event: {
-                type: EventType;
-                name: string;
-                amount: number;
-                count: number;
-                items: items[];
-                tier: EventTier;
-                month: string;
-                isTest: true;
-            };
-        };
-        type SessionRecent = {
-            listener: `${EventType}-recent`;
-            event: {
-                event: SessionRecentEvent[];
-            };
-        };
-        type SessionRecentEvent = {
-            type: EventType;
-            name: string;
-            amount: number;
-            count: number;
-            tier: EventTier;
-            isTest: true;
-        };
-        type SessionPoints = {
-            listener: `${EventType}-points`;
-            event: {
-                type: EventType;
-                name: string;
-                amount: number;
-                count: number;
-                items: items[];
-                tier: EventTier;
-                month: string;
-                isTest: true;
-            };
-        };
-        export {};
-    }
-    interface BaseEvent {
-        provider: Provider$1;
-        flagged: boolean;
-        channel: string;
-        createdAt: string;
-        _id: string;
-        expiresAt: string;
-        updatedAt: string;
-        activityId: string;
-        sessionEventsCount: number;
-        isMock?: boolean;
-    }
-    namespace Event {
-        type Data = {
-            listener: 'event';
-            event: Event;
-        };
-        type Event = Tip;
-        interface Tip extends BaseEvent {
-            type: 'tip';
-            data: {
-                amount: string;
-                currency: string;
-                username: string;
-                message: string;
-                avatar: string;
-            };
-        }
-    }
-}
-
 declare namespace YoutubeEvents {
     namespace Message {
         export type Data = {
@@ -1584,25 +1347,344 @@ declare namespace StreamElements {
     }
 }
 
-/**
- * EventProvider class for managing event listeners and emitters.
- * This class allows you to register event listeners, emit events, and manage event subscriptions.
- * @example
- * ```typescript
- * type TestEvents = {
- *   load: [event: { type: 'load' }];
- *   event: [event: { type: 'event' }];
- * };
- *
- * class Test extends EventProvider<TestEvents> {}
- *
- * const test = new Test();
- * test.once('load', (data) => {});
- * test.emit('load', { type: 'load' });
- *
- * test.on('event', (data) => {});
- * test.emit('event', { type: 'event' });
- * ```
+type Provider$1 = 'twitch' | 'youtube' | 'kick' | 'facebook' | 'streamelements';
+type ClientEvents$1 = {
+    provider: 'streamelements';
+    data: StreamElements.Event.Provider.StreamElements.Events;
+} | {
+    provider: 'twitch';
+    data: StreamElements.Event.Provider.Twitch.Events;
+} | {
+    provider: 'youtube';
+    data: StreamElements.Event.Provider.YouTube.Events;
+} | {
+    provider: 'kick';
+    data: StreamElements.Event.Provider.Kick.Events;
+} | {
+    provider: 'facebook';
+    data: StreamElements.Event.Provider.Facebook.Events;
+};
+
+declare namespace StreamElementsEvents {
+    namespace Tip {
+        type Data = {
+            listener: 'tip-latest';
+            event: Event;
+        };
+        type Event = {
+            amount: number;
+            avatar: string;
+            name: string;
+            displayName: string;
+            providerId: string;
+            _id: string;
+            sessionTop: boolean;
+            type: 'tip';
+            originalEventName: 'tip-latest';
+        };
+    }
+    namespace KVStore {
+        type Data = {
+            listener: 'kvstore:update';
+            event: Event;
+        };
+        type Event = {
+            data: {
+                key: `customWidget.${string}`;
+                value: string | number | boolean | Record<string, any>;
+            };
+        };
+    }
+    namespace BotCounter {
+        type Data = {
+            listener: 'bot:counter';
+            event: Event;
+        };
+        type Event = {
+            counter: string;
+            value: number;
+        };
+    }
+    namespace AlertService {
+        type Data = {
+            listener: 'alertService:toggleSound';
+            event: Event;
+        };
+        type Event = {
+            muted: boolean;
+        };
+    }
+    namespace EventSkip {
+        type Data = {
+            listener: 'event:skip';
+            event: Event;
+        };
+        type Event = {};
+    }
+    namespace EventTest {
+        export type Data = {
+            listener: 'event:test';
+            event: Event;
+        };
+        export type Event = widgetButton | emulatedEvents<EventType> | Session;
+        type items = {
+            name: string;
+            price: number;
+            quantity: number;
+        };
+        type widgetButton = {
+            listener: 'widget-button';
+            field: string;
+            value: string | number | boolean;
+        };
+        type EventType = 'follower' | 'subscriber' | 'tip' | 'cheer' | 'raid';
+        type EventTier = 'prime' | '1000' | '2000' | '3000';
+        type emulatedEvents<T extends EventType> = {
+            listener: `${T}-latest`;
+            event: {
+                type: T;
+                name: string;
+                amount: number;
+                count: number;
+                message?: string;
+                gifted?: boolean;
+                bulkGifted?: boolean;
+                sender?: string;
+                subExtension?: boolean;
+                items: items[];
+                tier: EventTier;
+                month: string;
+                isTest: true;
+            };
+        };
+        type Session = SessionCount | SessionTotal | SessionTop | SessionGoal | SessionRecent | SessionPoints;
+        type SessionCount = {
+            listener: `${EventType}-count`;
+            event: {
+                type: EventType;
+                name: string;
+                count: number;
+                items: items[];
+                tier: EventTier;
+                month: string;
+                isTest: true;
+            };
+        };
+        type SessionTotal = {
+            listener: `${EventType}-total`;
+            event: {
+                type: EventType;
+                name: string;
+                amount: number;
+                count: number;
+                items: items[];
+                tier: EventTier;
+                month: string;
+                isTest: true;
+            };
+        };
+        type SessionTop = {
+            listener: `${EventType}-top`;
+            event: {
+                type: EventType;
+                name: string;
+                amount: number;
+                count: number;
+                items: items[];
+                tier: EventTier;
+                month: string;
+                isTest: true;
+            };
+        };
+        type SessionGoal = {
+            listener: `${EventType}-goal`;
+            event: {
+                type: EventType;
+                name: string;
+                amount: number;
+                count: number;
+                items: items[];
+                tier: EventTier;
+                month: string;
+                isTest: true;
+            };
+        };
+        type SessionRecent = {
+            listener: `${EventType}-recent`;
+            event: {
+                event: SessionRecentEvent[];
+            };
+        };
+        type SessionRecentEvent = {
+            type: EventType;
+            name: string;
+            amount: number;
+            count: number;
+            tier: EventTier;
+            isTest: true;
+        };
+        type SessionPoints = {
+            listener: `${EventType}-points`;
+            event: {
+                type: EventType;
+                name: string;
+                amount: number;
+                count: number;
+                items: items[];
+                tier: EventTier;
+                month: string;
+                isTest: true;
+            };
+        };
+        export {};
+    }
+    interface BaseEvent {
+        provider: Provider$1;
+        flagged: boolean;
+        channel: string;
+        createdAt: string;
+        _id: string;
+        expiresAt: string;
+        updatedAt: string;
+        activityId: string;
+        sessionEventsCount: number;
+        isMock?: boolean;
+    }
+    namespace Event {
+        type Data = {
+            listener: 'event';
+            event: Event;
+        };
+        type Event = Tip;
+        interface Tip extends BaseEvent {
+            type: 'tip';
+            data: {
+                amount: string;
+                currency: string;
+                username: string;
+                message: string;
+                avatar: string;
+            };
+        }
+    }
+}
+
+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;
+
+interface ButtonOptions {
+    field: string | ((field: string, value: string | boolean | number) => boolean);
+    template?: string;
+    name?: string;
+    value?: string;
+    run: (field: string, value: string | boolean | number) => void;
+}
+/**
+ * Represents a button action that can be triggered by custom fields in StreamElements.
+ * The button can be configured with a template and a name, and it will execute a specified function when triggered.
+ * @example
+ * ```javascript
+ * const button = new Button({
+ *   field: (field, value) => field.startsWith('message-') && field.split('-')[1],
+ *   template: 'message-{role}',
+ *   // name: '[CAP={role}] role message',
+ *   name: 'Generate {role} message',
+ *   run(field, value) {
+ *     console.log(`Button ${field} was clicked with value: ${value}`);
+ *   }
+ * })
+ *
+ * const field = button.generate([{ role: 'broadcaster' }, { role: 'moderator' }]);
+ * // This will create buttons with fields "message-broadcaster" and "message-moderator" and names "Generate broadcaster message" and "Generate moderator message".
+ * // field['message-broadcaster'] => { type: 'button', label: 'Generate broadcaster message' }
+ * // field['message-moderator'] => { type: 'button', label: 'Generate moderator message' }
+ *
+ * // When a custom field with the name "message-broadcaster" or "message-moderator" is triggered, the run function will be called with the field and value.
+ * ```
+ */
+declare class Button {
+    field: ButtonOptions['field'];
+    template: string;
+    name: string;
+    value: string;
+    run: ButtonOptions['run'];
+    constructor(options: ButtonOptions);
+    generate(values: Array<Record<string, string | number>>): Record<string, StreamElements.CustomField.Schema>;
+    parse(field: string, value: string | boolean | number): Button;
+    remove(): void;
+    static execute(field: string, value: string | boolean | number): boolean;
+}
+
+/**
+ * EventProvider class for managing event listeners and emitters.
+ * This class allows you to register event listeners, emit events, and manage event subscriptions.
+ * @example
+ * ```typescript
+ * type TestEvents = {
+ *   load: [event: { type: 'load' }];
+ *   event: [event: { type: 'event' }];
+ * };
+ *
+ * class Test extends EventProvider<TestEvents> {}
+ *
+ * const test = new Test();
+ * test.once('load', (data) => {});
+ * test.emit('load', { type: 'load' });
+ *
+ * test.on('event', (data) => {});
+ * test.emit('event', { type: 'event' });
+ * ```
  */
 declare class EventProvider<EventMap extends Record<string, any[]> = Record<string, any[]>> {
     /**
@@ -1698,250 +1780,682 @@ declare class useStorage<T extends JSONObject> extends EventProvider<UseStorageE
     on<K extends keyof UseStorageEvents<T>>(eventName: K, callback: (this: useStorage<T>, ...args: UseStorageEvents<T>[K]) => void): this;
 }
 
-declare namespace Alejo {
-    namespace Pronouns {
-        type name = 'hehim' | 'sheher' | 'theythem' | 'shethem' | 'hethem' | 'heshe' | 'xexem' | 'faefaer' | 'vever' | 'aeaer' | 'ziehir' | 'perper' | 'eem' | 'itits';
-        type display = 'He/Him' | 'She/Her' | 'They/Them' | 'She/They' | 'He/They' | 'He/She' | 'Xe/Xem' | 'Fae/Faer' | 'Ve/Ver' | 'Ae/Aer' | 'Zie/Hir' | 'Per/Per' | 'E/Em' | 'It/Its';
-        enum map {
-            hehim = "He/Him",
-            sheher = "She/Her",
-            theythem = "They/Them",
-            shethem = "She/They",
-            hethem = "He/They",
-            heshe = "He/She",
-            xexem = "Xe/Xem",
-            faefaer = "Fae/Faer",
-            vever = "Ve/Ver",
-            aeaer = "Ae/Aer",
-            ziehir = "Zie/Hir",
-            perper = "Per/Per",
-            eem = "E/Em",
-            itits = "It/Its"
+declare namespace Alejo {
+    namespace Pronouns {
+        type name = 'hehim' | 'sheher' | 'theythem' | 'shethem' | 'hethem' | 'heshe' | 'xexem' | 'faefaer' | 'vever' | 'aeaer' | 'ziehir' | 'perper' | 'eem' | 'itits';
+        type display = 'He/Him' | 'She/Her' | 'They/Them' | 'She/They' | 'He/They' | 'He/She' | 'Xe/Xem' | 'Fae/Faer' | 'Ve/Ver' | 'Ae/Aer' | 'Zie/Hir' | 'Per/Per' | 'E/Em' | 'It/Its';
+        enum map {
+            hehim = "He/Him",
+            sheher = "She/Her",
+            theythem = "They/Them",
+            shethem = "She/They",
+            hethem = "He/They",
+            heshe = "He/She",
+            xexem = "Xe/Xem",
+            faefaer = "Fae/Faer",
+            vever = "Ve/Ver",
+            aeaer = "Ae/Aer",
+            ziehir = "Zie/Hir",
+            perper = "Per/Per",
+            eem = "E/Em",
+            itits = "It/Its"
+        }
+    }
+    function list(): Promise<typeof Pronouns.map>;
+    type user = {
+        id: string;
+        login: string;
+        pronoun_id: Pronouns.name;
+    };
+    function get(username: string): Promise<Pronouns.name | undefined>;
+}
+
+type ClientEvents = {
+    load: [event: StreamElements.Event.onWidgetLoad];
+    action: [action: Button | Command, type: 'created' | 'executed' | 'removed'];
+    session: [session: StreamElements.Session.Data];
+    event: [provider: 'streamelements', event: StreamElements.Event.Provider.StreamElements.Events] | [provider: 'twitch', event: StreamElements.Event.Provider.Twitch.Events] | [provider: 'youtube', event: StreamElements.Event.Provider.YouTube.Events] | [provider: 'kick', event: StreamElements.Event.Provider.Kick.Events] | [provider: 'facebook', event: StreamElements.Event.Provider.Facebook.Events];
+};
+type ClientStorageOptions<T> = {
+    value: T;
+    timestamp: number;
+    expire: number;
+};
+type ClientStorage = {
+    user: Record<string, ClientStorageOptions<string>>;
+    avatar: Record<string, ClientStorageOptions<string>>;
+    pronoun: Record<string, ClientStorageOptions<Alejo.Pronouns.name>>;
+    emote: Record<string, ClientStorageOptions<string>>;
+};
+type ClientOptions = {
+    id?: string;
+    debug?: boolean | (() => boolean);
+};
+declare class Client extends EventProvider<ClientEvents> {
+    id: string;
+    debug: boolean;
+    storage: useStorage<ClientStorage>;
+    fields: StreamElements.Event.onWidgetLoad['fieldData'];
+    session: StreamElements.Session.Data;
+    loaded: boolean;
+    constructor(options: ClientOptions);
+    actions: {
+        commands: Command[];
+        buttons: Button[];
+    };
+    details: {
+        provider: Provider$1 | 'local';
+        user: StreamElements.Event.onWidgetLoad['channel'];
+        currency: StreamElements.Event.onWidgetLoad['currency'];
+        overlay: StreamElements.Event.onWidgetLoad['overlay'];
+    };
+    cache: {
+        /**
+         * Avatar cache duration in minutes.
+         */
+        avatar: number;
+        /**
+         * Pronoun cache duration in minutes.
+         */
+        pronoun: number;
+        /**
+         * Emote cache duration in minutes.
+         */
+        emote: number;
+    };
+    on<K extends keyof ClientEvents>(eventName: K, callback: (this: Client, ...args: ClientEvents[K]) => void): this;
+}
+
+interface CommandOptions {
+    prefix?: string;
+    name: string;
+    description?: string;
+    arguments?: boolean;
+    run: (this: Client, args: string[], event: CommandEvent) => void;
+    test?: string;
+    aliases?: string[];
+    permissions?: string[];
+    admins?: string[];
+}
+type CommandEvent = {
+    provider: 'twitch';
+    data: StreamElements.Event.Provider.Twitch.Message;
+} | {
+    provider: 'youtube';
+    data: StreamElements.Event.Provider.YouTube.Message;
+} | {
+    provider: 'kick';
+    data: any;
+};
+declare class Command {
+    prefix: string;
+    name: string;
+    description: string;
+    arguments: boolean;
+    test: string | (() => string);
+    aliases: string[];
+    permissions?: string[] | boolean;
+    admins: string[];
+    constructor(options: CommandOptions);
+    run(this: Client, args: string[], event: CommandEvent): void;
+    verify(nickname: string, roles: string[], args: string[]): boolean;
+    parse(text: string, event: CommandEvent): boolean;
+    remove(): void;
+    static execute(received: CommandEvent): boolean;
+}
+
+type QueueEvents<T> = {
+    load: [];
+    cancel: [];
+    update: [queue: QueueItem<T>[], priorityQueue: QueueItem<T>[], history: QueueItem<T>[], timeouts: Array<ReturnType<typeof setTimeout>>];
+    process: [item: QueueItem<T>, queue: useQueue<T>];
+};
+type QueueProps = {
+    isoDate: string;
+    isLoop: boolean;
+    isPriority: boolean;
+    isImmediate: boolean;
+};
+type QueueItem<T> = {
+    value: T;
+} & QueueProps;
+type QueueProcessor<T> = (item: T, queue: useQueue<T>) => Promise<any>;
+type QueueDuration = number | boolean | undefined;
+interface QueueOptions<T> {
+    /**
+     * Duration between processing each item in milliseconds. Set to `0` or `false` for immediate processing.
+     */
+    duration?: QueueDuration | 'client';
+    /**
+     * Function to process each item in the queue.
+     */
+    processor: QueueProcessor<T>;
+}
+/**
+ * A utility class to manage a queue of items with support for priority, looping, and immediate processing.
+ * @template T - The type of items in the queue.
+ * @extends EventProvider<QueueEvents<T>>
+ * @example
+ * ```javascript
+ * const myQueue = new useQueue({
+ *   duration: 1000,
+ *   processor: async (item) => {
+ *    console.log('Processing item:', item);
+ *  },
+ * });
+ *
+ * myQueue.enqueue('Item 1');
+ * myQueue.enqueue('Item 2', { isPriority: true });
+ * ```
+ */
+declare class useQueue<T> extends EventProvider<QueueEvents<T>> {
+    queue: QueueItem<T>[];
+    priorityQueue: QueueItem<T>[];
+    history: QueueItem<T>[];
+    private timeouts;
+    running: boolean;
+    duration: QueueDuration;
+    private loaded;
+    processor: QueueProcessor<T>;
+    constructor(options: QueueOptions<T>);
+    enqueue(value: T, options?: Partial<QueueProps>): this;
+    private run;
+    private next;
+    resume(): this;
+    update(save: Partial<useQueue<T>>): this;
+    cancel(): void;
+    hasItems(): boolean;
+    on<K extends keyof QueueEvents<T>>(eventName: K, callback: (this: useQueue<T>, ...args: QueueEvents<T>[K]) => void): this;
+}
+
+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;
     }
-    function list(): Promise<typeof Pronouns.map>;
-    type user = {
-        id: string;
-        login: string;
-        pronoun_id: Pronouns.name;
-    };
-    function get(username: string): Promise<Pronouns.name | undefined>;
-}
-
-type ClientEvents = {
-    load: [event: StreamElements.Event.onWidgetLoad];
-    action: [action: Button | Command, type: 'created' | 'executed' | 'removed'];
-    session: [session: StreamElements.Session.Data];
-    event: [provider: 'streamelements', event: StreamElements.Event.Provider.StreamElements.Events] | [provider: 'twitch', event: StreamElements.Event.Provider.Twitch.Events] | [provider: 'youtube', event: StreamElements.Event.Provider.YouTube.Events] | [provider: 'kick', event: StreamElements.Event.Provider.Kick.Events] | [provider: 'facebook', event: StreamElements.Event.Provider.Facebook.Events];
-};
-type ClientStorageOptions<T> = {
-    value: T;
-    timestamp: number;
-    expire: number;
-};
-type ClientStorage = {
-    user: Record<string, ClientStorageOptions<string>>;
-    avatar: Record<string, ClientStorageOptions<string>>;
-    pronoun: Record<string, ClientStorageOptions<Alejo.Pronouns.name>>;
-    emote: Record<string, ClientStorageOptions<string>>;
-};
-type ClientOptions = {
-    id?: string;
-    debug?: boolean | (() => boolean);
-};
-declare class Client extends EventProvider<ClientEvents> {
-    id: string;
-    debug: boolean;
-    storage: useStorage<ClientStorage>;
-    fields: StreamElements.Event.onWidgetLoad['fieldData'];
-    session: StreamElements.Session.Data;
-    loaded: boolean;
-    constructor(options: ClientOptions);
-    actions: {
-        commands: Command[];
-        buttons: Button[];
-    };
-    details: {
-        provider: Provider$1 | 'local';
-        user: StreamElements.Event.onWidgetLoad['channel'];
-        currency: StreamElements.Event.onWidgetLoad['currency'];
-        overlay: StreamElements.Event.onWidgetLoad['overlay'];
-    };
-    cache: {
+    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;
         /**
-         * Avatar cache duration in minutes.
+         * 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)
+         * ```
          */
-        avatar: number;
+        function boolean(threshold?: number): boolean;
         /**
-         * Pronoun cache duration in minutes.
+         * 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"
+         * ```
          */
-        pronoun: number;
+        function string(length: number, chars?: string): string;
         /**
-         * Emote cache duration in minutes.
+         * 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
+         * ```
          */
-        emote: number;
-    };
-    on<K extends keyof ClientEvents>(eventName: K, callback: (this: Client, ...args: ClientEvents[K]) => void): this;
-}
-
-interface CommandOptions {
-    prefix?: string;
-    name: string;
-    description?: string;
-    arguments?: boolean;
-    run: (this: Client, args: string[], event: CommandEvent) => void;
-    test?: string;
-    aliases?: string[];
-    permissions?: string[];
-    admins?: string[];
-}
-type CommandEvent = {
-    provider: 'twitch';
-    data: StreamElements.Event.Provider.Twitch.Message;
-} | {
-    provider: 'youtube';
-    data: StreamElements.Event.Provider.YouTube.Message;
-} | {
-    provider: 'kick';
-    data: any;
-};
-declare class Command {
-    prefix: string;
-    name: string;
-    description: string;
-    arguments: boolean;
-    test: string;
-    aliases: string[];
-    permissions?: string[] | boolean;
-    admins: string[];
-    constructor(options: CommandOptions);
-    run(this: Client, args: string[], event: CommandEvent): void;
-    verify(nickname: string, roles: string[], args: string[]): boolean;
-    parse(text: string, event: CommandEvent): boolean;
-    remove(): void;
-    static execute(received: CommandEvent): boolean;
-}
-
-type QueueEvents<T> = {
-    load: [];
-    cancel: [];
-    update: [queue: QueueItem<T>[], priorityQueue: QueueItem<T>[], history: QueueItem<T>[], timeouts: Array<ReturnType<typeof setTimeout>>];
-    process: [item: QueueItem<T>, queue: useQueue<T>];
-};
-type QueueProps = {
-    isoDate: string;
-    isLoop: boolean;
-    isPriority: boolean;
-    isImmediate: boolean;
-};
-type QueueItem<T> = {
-    value: T;
-} & QueueProps;
-type QueueProcessor<T> = (item: T, queue: useQueue<T>) => Promise<any>;
-type QueueDuration = number | boolean | undefined;
-interface QueueOptions<T> {
-    /**
-     * Duration between processing each item in milliseconds. Set to `0` or `false` for immediate processing.
-     */
-    duration?: QueueDuration | 'client';
-    /**
-     * Function to process each item in the queue.
-     */
-    processor: QueueProcessor<T>;
-}
-/**
- * A utility class to manage a queue of items with support for priority, looping, and immediate processing.
- * @template T - The type of items in the queue.
- * @extends EventProvider<QueueEvents<T>>
- * @example
- * ```javascript
- * const myQueue = new useQueue({
- *   duration: 1000,
- *   processor: async (item) => {
- *    console.log('Processing item:', item);
- *  },
- * });
- *
- * myQueue.enqueue('Item 1');
- * myQueue.enqueue('Item 2', { isPriority: true });
- * ```
- */
-declare class useQueue<T> extends EventProvider<QueueEvents<T>> {
-    queue: QueueItem<T>[];
-    priorityQueue: QueueItem<T>[];
-    history: QueueItem<T>[];
-    private timeouts;
-    running: boolean;
-    duration: QueueDuration;
-    private loaded;
-    processor: QueueProcessor<T>;
-    constructor(options: QueueOptions<T>);
-    enqueue(value: T, options?: Partial<QueueProps>): this;
-    private run;
-    private next;
-    resume(): this;
-    update(save: Partial<useQueue<T>>): this;
-    cancel(): void;
-    hasItems(): boolean;
-    on<K extends keyof QueueEvents<T>>(eventName: K, callback: (this: useQueue<T>, ...args: QueueEvents<T>[K]) => void): this;
+        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;
+    }
 }
 
-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;
-type BadgeOptions = Twitch.roles[] | Twitch.roles | `${Twitch.roles}, ${Twitch.roles}` | `${Twitch.roles}, ${Twitch.roles}, ${Twitch.roles}`;
-
 declare namespace Local {
     type Queue = useQueue<{
         listener: 'onEventReceived';
@@ -1999,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;
@@ -2046,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;
@@ -2175,142 +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>): [K, V][];
-        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>;
@@ -2387,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 };