@tixyel/streamelements 7.5.1 → 7.5.2

package/dist/index.d.ts

@@ -7,228 +7,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';
 export { ComfyJSInstance } from 'comfy.js';
 
-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;
@@ -1681,46 +1459,334 @@ declare namespace StreamElements {
     }
 }
 
-interface CommandOptions {
-    prefix?: string;
-    name: string;
-    description?: string;
-    arguments?: boolean;
-    run: (this: Client, args: string[], event: CommandEvent) => void;
-    test?: string;
-    aliases?: string[];
-    permissions?: string[] | boolean;
-    admins?: string[];
-}
-type CommandEvent = {
-    provider: 'twitch';
-    data: StreamElements.Event.Provider.Twitch.Message;
-} | {
-    provider: 'youtube';
-    data: StreamElements.Event.Provider.YouTube.Message;
-} | {
-    provider: 'kick';
-    data: any;
+type Provider$1 = 'twitch' | 'youtube' | 'kick' | 'facebook' | 'streamelements';
+type ClientProviderEvents = {
+    streamelements: StreamElements.Event.Provider.StreamElements.Events;
+    twitch: StreamElements.Event.Provider.Twitch.Events;
+    youtube: StreamElements.Event.Provider.YouTube.Events;
+    kick: StreamElements.Event.Provider.Kick.Events;
+    facebook: StreamElements.Event.Provider.Facebook.Events;
 };
-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 | undefined, 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 ClientCustomEventPayload = {
+    provider: 'custom';
+};
+type ClientCustomProviderEvents = Record<string, ClientCustomEventPayload>;
+type ValidateCustomProviderEvents<CustomEvents> = CustomEvents extends Record<string, unknown> ? {
+    [K in keyof CustomEvents]: CustomEvents[K] extends ClientCustomEventPayload ? CustomEvents[K] : never;
+} : {};
+type ClientAllProviderEvents<CustomEvents = {}> = ClientProviderEvents & ValidateCustomProviderEvents<CustomEvents>;
+type ClientEvents<CustomEvents = {}> = {
+    [K in keyof ClientAllProviderEvents<CustomEvents> & string]: {
+        provider: K;
+        data: ClientAllProviderEvents<CustomEvents>[K];
+    };
+}[keyof ClientAllProviderEvents<CustomEvents> & string];
+type ClientEventTuple<CustomEvents = {}> = {
+    [K in keyof ClientAllProviderEvents<CustomEvents> & string]: [
+        provider: K,
+        event: ClientAllProviderEvents<CustomEvents>[K]
+    ];
+}[keyof ClientAllProviderEvents<CustomEvents> & string];
 
-/**
- * EventProvider class for managing event listeners and emitters.
+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 JSONPrimitive = string | number | boolean | null;
+type JSONSerializable = JSONPrimitive | JSONSerializable[] | {
+    [k: string]: JSONSerializable | undefined;
+};
+type JSONObject = {
+    [key: string]: JSONSerializable | undefined;
+};
+
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+
+interface ButtonOptions {
+    field: string | ((field: string, value: string | boolean | number) => boolean);
+    template?: string;
+    name?: string;
+    value?: string;
+    run: (this: Client | undefined, 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;
+}
+
+interface CommandOptions {
+    prefix?: string;
+    name: string;
+    description?: string;
+    arguments?: boolean;
+    run: (this: Client, args: string[], event: CommandEvent) => void;
+    test?: string;
+    aliases?: string[];
+    permissions?: string[] | boolean;
+    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 | undefined, 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;
+}
+
+/**
+ * EventProvider class for managing event listeners and emitters.
  * This class allows you to register event listeners, emit events, and manage event subscriptions.
  * @example
  * ```typescript
@@ -1776,14 +1842,6 @@ declare class EventProvider<EventMap extends Record<string, any[]> = Record<stri
     removeAllListeners<K extends keyof EventMap>(eventName: K): this;
 }
 
-type JSONPrimitive = string | number | boolean | null;
-type JSONSerializable = JSONPrimitive | JSONSerializable[] | {
-    [k: string]: JSONSerializable | undefined;
-};
-type JSONObject = {
-    [key: string]: JSONSerializable | undefined;
-};
-
 type UseStorageEvents<T> = {
     load: [T | null];
     update: [T];
@@ -1860,11 +1918,11 @@ declare namespace Alejo {
     function get(username: string): Promise<Pronouns.name | undefined>;
 }
 
-type ClientEvents = {
+type ClientMapEvents<CustomEvents = {}> = {
     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];
+    event: ClientEventTuple<CustomEvents>;
 };
 type ClientStorageOptions<T> = {
     value: T;
@@ -1881,7 +1939,7 @@ type ClientOptions = {
     id?: string;
     debug?: boolean | (() => boolean);
 };
-declare class Client extends EventProvider<ClientEvents> {
+declare class Client<CustomEvents = {}> extends EventProvider<ClientMapEvents<CustomEvents>> {
     id: string;
     debug: boolean;
     storage: useStorage<ClientStorage>;
@@ -1913,54 +1971,7 @@ declare class Client extends EventProvider<ClientEvents> {
          */
         emote: number;
     };
-    on<K extends keyof ClientEvents>(eventName: K, callback: (this: Client, ...args: ClientEvents[K]) => void): this;
-}
-
-type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
-    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
-}[Keys];
-
-interface ButtonOptions {
-    field: string | ((field: string, value: string | boolean | number) => boolean);
-    template?: string;
-    name?: string;
-    value?: string;
-    run: (this: Client | undefined, 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;
+    on<K extends keyof ClientMapEvents<CustomEvents>>(eventName: K, callback: (this: Client<CustomEvents>, ...args: ClientMapEvents<CustomEvents>[K]) => void): this;
 }
 
 interface Theme {
@@ -2742,7 +2753,7 @@ declare class EventHelper {
      * @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, overrideProvider?: Provider$1): ClientEvents$1;
+    parseProvider(detail: StreamElements.Event.onEventReceived, overrideProvider?: Provider$1): ClientEvents;
 }
 
 type Modifier = (value: string, param: string | null | undefined, values: {
@@ -3490,7 +3501,7 @@ declare function onWidgetLoad(fields: Record<string, StreamElements.CustomField.
  * @param session - The session data to be included in the event.
  * @returns A Promise that resolves to the simulated onSessionUpdate event data.
  */
-declare function onSessionUpdate(session?: StreamElements.Session.Data, update?: ClientEvents$1): Promise<StreamElements.Event.onSessionUpdate>;
+declare function onSessionUpdate(session?: StreamElements.Session.Data, update?: ClientEvents): Promise<StreamElements.Event.onSessionUpdate>;
 /**
  * Simulates the onEventReceived event for a widget.
  * @param provider - The provider of the event (default is 'random').
@@ -3678,7 +3689,7 @@ declare const main: {
 declare global {
     interface Window {
         Tixyel: typeof main;
-        client: InstanceType<typeof main.Client> | undefined;
+        client: Client | undefined;
         ComfyJS?: ComfyJSInstance;
     }
     interface WindowEventMap {
@@ -3687,9 +3698,9 @@ declare global {
         onEventReceived: CustomEvent<StreamElements.Event.onEventReceived>;
     }
     const Tixyel: typeof main;
-    let client: InstanceType<typeof main.Client> | undefined;
+    let client: Client | undefined;
     const SE_API: StreamElements.SE_API;
 }
 
 export { Alejo, Button, Command, EventProvider, StreamElements, StreamElementsEvents, Twitch, TwitchEvents, YoutubeEvents, main as default, useComfyJs, useLogger, useQueue, useStorage };
-export type { BttvEmote, ClientEvents$1 as ClientEvents, Emoji, Emote, FfzEmote, JSONObject, JSONPrimitive, JSONSerializable, MapNumberValuesToString, NumberAsString, PathValue, Provider$1 as Provider, RequireAtLeastOne, SeventvEmote, TwitchEmote };
+export type { BttvEmote, ClientCustomEventPayload, ClientCustomProviderEvents, ClientEventTuple, ClientEvents, ClientProviderEvents, Emoji, Emote, FfzEmote, JSONObject, JSONPrimitive, JSONSerializable, MapNumberValuesToString, NumberAsString, PathValue, Provider$1 as Provider, RequireAtLeastOne, SeventvEmote, TwitchEmote };