@crowbartools/firebot-types 5.67.0-alpha4 → 5.67.0-alpha6

package/backend/streaming-platforms/twitch/api/resource/predictions.d.ts

@@ -0,0 +1,39 @@
+import { HelixPrediction } from "@twurple/api";
+import { ApiResourceBase } from './api-resource-base';
+import type { TwitchApi } from "../";
+export declare class TwitchPredictionsApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    /**
+     * Creates a Twitch prediction
+     *
+     * @param title Title of the prediction
+     * @param outcomes List of outcomes for the prediction. Minimum of 2, maximum of 10.
+     * @param duration Duration in seconds to allow predictions. Minimum of 30, maximum of 1800 (30 minutes).
+     */
+    createPrediction(title: string, outcomes: string[], duration: number): Promise<void>;
+    /**
+     * Locks a Twitch prediction so no more predictions can be made
+     *
+     * @param predictionId The prediction ID.
+     */
+    lockPrediciton(predictionId: string): Promise<void>;
+    /**
+     * Cancels a Twitch prediction and refunds all wagered channel points
+     *
+     * @param predictionId The prediction ID.
+     */
+    cancelPrediction(predictionId: string): Promise<void>;
+    /**
+     * Resolve a Twitch prediction.
+     *
+     * @param predictionId The prediction ID.
+     * @param outcomeId The winning outcome ID.
+     */
+    resolvePrediction(predictionId: string, outcomeId: string): Promise<void>;
+    /**
+     * Retrieve the most recent Twitch prediction
+     *
+     * @returns A HelixPrediction object with the most recent Twitch prediction data
+     */
+    getMostRecentPrediction(): Promise<HelixPrediction>;
+}

package/backend/streaming-platforms/twitch/api/resource/streams.d.ts

@@ -0,0 +1,12 @@
+import { HelixStream, HelixStreamMarker } from "@twurple/api";
+import { ApiResourceBase } from './api-resource-base';
+import type { TwitchApi } from "../";
+export declare class TwitchStreamsApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    createStreamMarker(description?: string): Promise<HelixStreamMarker>;
+    /**
+     * Get the streamers current stream. Null if offline.
+     */
+    getStreamersCurrentStream(): Promise<HelixStream | null>;
+    getStreamUptime(): Promise<string>;
+}

package/backend/streaming-platforms/twitch/api/resource/subscriptions.d.ts

@@ -0,0 +1,24 @@
+import { ApiResourceBase } from './api-resource-base';
+import type { TwitchApi } from "../";
+import { HelixSubscription } from '@twurple/api/lib';
+export declare class TwitchSubscriptionsApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    /**
+     * Retrieves the subscription info for all users who are currently subscribed to the streamer
+     *
+     * @returns {HelixSubscription[]}
+     */
+    getSubscriptions(): Promise<HelixSubscription[]>;
+    /**
+     * Retrieves the number of subscribers the streamer has
+     *
+     * @returns Number of subscribers the streamer has
+     */
+    getSubscriberCount(): Promise<number>;
+    /**
+     * Retrieves the number of sub points the streamer has
+     *
+     * @returns Number of sub points the streamer has
+     */
+    getSubPointCount(): Promise<number>;
+}

package/backend/streaming-platforms/twitch/api/resource/teams.d.ts

@@ -0,0 +1,11 @@
+import { HelixTeam } from "@twurple/api";
+import { ApiResourceBase } from "./api-resource-base";
+import type { TwitchApi } from "../";
+export declare class TwitchTeamsApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    getTeams(broadcasterId: string): Promise<HelixTeam[]>;
+    getMatchingTeams(userId: string): Promise<HelixTeam[]>;
+    getMatchingTeamsByName(username: string): Promise<HelixTeam[]>;
+    getMatchingTeamsById(userId: string): Promise<HelixTeam[]>;
+    getStreamerTeams(): Promise<HelixTeam[]>;
+}

package/backend/streaming-platforms/twitch/api/resource/users.d.ts

@@ -0,0 +1,20 @@
+import { HelixChannelFollower, HelixUser, UserIdResolvable } from "@twurple/api";
+import { ApiResourceBase } from "./api-resource-base";
+import type { TwitchApi } from "../";
+export declare class TwitchUsersApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    getUserById(userId: string): Promise<HelixUser>;
+    getUsersByIds(userIds: string[]): Promise<HelixUser[]>;
+    getUserByName(username: string): Promise<HelixUser>;
+    getUsersByNames(usernames: string[]): Promise<HelixUser[]>;
+    getFollowDateForUser(username: string): Promise<Date>;
+    /**
+     * @param username
+     * @param channelName
+     * @returns {Promise<HelixChannelFollower | boolean>} true when username === channelName, false when not following
+     */
+    getUserChannelFollow(username: string, channelName: string): Promise<HelixChannelFollower | boolean>;
+    doesUserFollowChannel(username: string, channelName: string): Promise<boolean>;
+    blockUser(userId: UserIdResolvable, reason?: 'spam' | 'harassment' | 'other'): Promise<boolean>;
+    unblockUser(userId: UserIdResolvable): Promise<boolean>;
+}

package/backend/streaming-platforms/twitch/api/resource/videos.d.ts

@@ -0,0 +1,12 @@
+import { HelixVideo } from "@twurple/api";
+import { ApiResourceBase } from "./api-resource-base";
+import type { TwitchApi } from "../";
+export declare class TwitchVideosApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    /**
+     * Gets the VOD object for the specified stream
+     * @param streamId ID of the stream
+     * @returns A {@linkcode HelixVideo} object representing the VOD
+     */
+    getVodByStreamId(streamId: string): Promise<HelixVideo>;
+}

package/backend/streaming-platforms/twitch/api/resource/whispers.d.ts

@@ -0,0 +1,17 @@
+import { UserIdResolvable } from "@twurple/api";
+import { ApiResourceBase } from "./api-resource-base";
+import type { TwitchApi } from "../";
+export declare class TwitchWhispersApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    /**
+     * Sends a whisper to another user.
+     *
+     * @param recipientUserId The Twitch user ID of the recipient user
+     * @param message The message to send
+     * @param sendAsBot If the whisper should be sent as the bot or not.
+     * If this is set to `false`, the whisper will be sent as the streamer.
+     * @returns `true` if the request was successful or `false` if the request failed.
+     * NOTE: Twitch may return a success even for whispers that are not sent for being suspected of spam.
+     */
+    sendWhisper(recipientUserId: UserIdResolvable, message: string, sendAsBot?: boolean): Promise<boolean>;
+}

package/backend/streaming-platforms/twitch/api/user-context-api-client.d.ts

@@ -0,0 +1,12 @@
+import { ApiClient, ApiConfig } from "@twurple/api";
+/**
+ * A Twurple API client that always acts in the context of the specified user.
+ *
+ * Functionally equivalent to Twurple's internal `UserContextApiClient` class
+ * used in the callback for `ApiClient.asUser`
+ */
+export declare class UserContextApiClient extends ApiClient {
+    private readonly _userId;
+    constructor(config: ApiConfig, _userId: string);
+    _getUserIdFromRequestContext(): string;
+}

package/backend/streaming-platforms/twitch/auth/twitch-auth.d.ts

@@ -0,0 +1,14 @@
+import type { AuthProviderDefinition } from "../../../../types/auth";
+declare class TwitchAuthProviders {
+    private readonly _host;
+    private readonly _authorizePath;
+    private readonly _tokenPath;
+    readonly streamerAccountProviderId = "twitch:streamer-account";
+    readonly botAccountProviderId = "twitch:bot-account";
+    readonly twitchClientId: string;
+    readonly streamerAccountProvider: AuthProviderDefinition;
+    botAccountProvider: AuthProviderDefinition;
+    registerTwitchAuthProviders(): void;
+}
+declare const twitchAuthProviders: TwitchAuthProviders;
+export { twitchAuthProviders as TwitchAuthProviders };

package/backend/streaming-platforms/twitch/auth/twitch-device-auth-provider.d.ts

@@ -0,0 +1,97 @@
+/**
+ *  This file exists because there's currently no Twurple AuthProvider that supports Device Code Flow.
+ *  Once one exists, this can go away. In the meantime, it stays in order to refresh tokens automagically.
+ */
+import { EventEmitter } from "@d-fischer/typed-event-emitter";
+import { type AuthProvider, AccessToken, AccessTokenMaybeWithUserId, AccessTokenWithUserId } from "@twurple/auth";
+import { type UserIdResolvable, CustomError } from "@twurple/common";
+/**
+ * Thrown whenever you try to execute an action in the context of a user
+ * who is already known to have an invalid token saved in its {@link AuthProvider}.
+ */
+export declare class CachedRefreshFailureError extends CustomError {
+    readonly userId: string;
+    constructor(userId: string);
+}
+interface DeviceAuthProviderConfig {
+    userId: UserIdResolvable;
+    clientId: string;
+    accessToken: AccessToken;
+}
+/**
+ * An auth provider that returns a refreshable token for a given user obtained via Device Code Flow.
+ */
+export declare class DeviceAuthProvider extends EventEmitter implements AuthProvider {
+    private _userId;
+    private readonly _clientId;
+    private _accessToken;
+    private _tokenFetcher;
+    private _refreshPromise;
+    private readonly _cachedRefreshFailures;
+    /**
+     * Fires when a user token is refreshed.
+     *
+     * @param userId The ID of the user whose token was successfully refreshed.
+     * @param token The refreshed token data.
+     */
+    readonly onRefresh: import("@d-fischer/typed-event-emitter").EventBinder<[userId: string, token: AccessToken]>;
+    /**
+     * Fires when a user token fails to refresh.
+     *
+     * @param userId The ID of the user whose token wasn't successfully refreshed.
+     */
+    readonly onRefreshFailure: import("@d-fischer/typed-event-emitter").EventBinder<[userId: string, isENotFoundError: boolean]>;
+    /**
+     * Creates a new auth provider with Device Code Flow credentials.
+     *
+     * @param deviceAuthConfig The config values for the Device Code Flow auth provider
+     */
+    constructor(deviceAuthConfig: DeviceAuthProviderConfig);
+    /**
+     * Requests that the provider fetches a new token from Twitch.
+     *
+     * @param user Ignored.
+     */
+    refreshAccessTokenForUser(user: UserIdResolvable): Promise<AccessTokenWithUserId>;
+    /**
+     * Requests that the provider fetches a new token from Twitch.
+     *
+     * @param intent Ignored.
+     */
+    refreshAccessTokenForIntent(intent: string): Promise<AccessTokenWithUserId>;
+    /**
+     * The client ID.
+     */
+    get clientId(): string;
+    /**
+     * The scopes that are currently available using the access token.
+     */
+    getCurrentScopesForUser(user: UserIdResolvable): string[];
+    /**
+     * Gets the access token.
+     *
+     * If the current access token does not have the requested scopes, this method throws.
+     * This makes supplying an access token with the correct scopes from the beginning necessary.
+     *
+     * @param user Ignored.
+     * @param scopeSets The requested scopes.
+     */
+    getAccessTokenForUser(user: UserIdResolvable, ...scopeSets: Array<string[] | undefined>): Promise<AccessTokenWithUserId>;
+    /**
+     * Gets the access token.
+     *
+     * If the current access token does not have the requested scopes, this method throws.
+     * This makes supplying an access token with the correct scopes from the beginning necessary.
+     *
+     * @param intent Ignored.
+     * @param scopeSets The requested scopes.
+     */
+    getAccessTokenForIntent(intent: string, ...scopeSets: Array<string[] | undefined>): Promise<AccessTokenWithUserId>;
+    /**
+     * Gets the access token.
+     */
+    getAnyAccessToken(): Promise<AccessTokenMaybeWithUserId>;
+    private _fetchUserToken;
+    private _refreshUserTokenWithCallback;
+}
+export {};

package/backend/streaming-platforms/twitch/chat/shared-chat-cache.d.ts

@@ -0,0 +1,13 @@
+import type { SharedChatParticipant } from '../../../../types';
+declare class SharedChatCache {
+    private _isActive;
+    private _participants;
+    get isActive(): boolean;
+    enableSharedChat(): void;
+    disableSharedChat(): void;
+    get participants(): Record<string, SharedChatParticipant>;
+    set participants(participants: Array<SharedChatParticipant>);
+    loadSessionFromTwitch(): Promise<void>;
+}
+declare const cache: SharedChatCache;
+export { cache as SharedChatCache };

package/backend/streaming-platforms/twitch/chat/slash-commands/channel-handlers.d.ts

@@ -0,0 +1,4 @@
+import { TwitchSlashCommand } from "../twitch-slash-commands";
+export declare const commercialHandler: TwitchSlashCommand<[number]>;
+export declare const raidHandler: TwitchSlashCommand<[string]>;
+export declare const unraidHandler: TwitchSlashCommand<[]>;

package/backend/streaming-platforms/twitch/chat/slash-commands/chat-handlers.d.ts

@@ -0,0 +1,19 @@
+import { TwitchSlashCommand } from "../twitch-slash-commands";
+export declare const whisperHandler: TwitchSlashCommand<[string, string]>;
+export declare const announceHandler: TwitchSlashCommand<[string]>;
+export declare const announceblueHandler: TwitchSlashCommand<[string]>;
+export declare const announcegreenHandler: TwitchSlashCommand<[string]>;
+export declare const announceorangeHandler: TwitchSlashCommand<[string]>;
+export declare const announcepurpleHandler: TwitchSlashCommand<[string]>;
+export declare const shoutoutHandler: TwitchSlashCommand<[string]>;
+export declare const clearHandler: TwitchSlashCommand<[]>;
+export declare const emoteonlyHandler: TwitchSlashCommand<[]>;
+export declare const emoteonlyoffHandler: TwitchSlashCommand<[]>;
+export declare const followersHandler: TwitchSlashCommand<[number]>;
+export declare const followersoffHandler: TwitchSlashCommand<[]>;
+export declare const subscribersHandler: TwitchSlashCommand<[]>;
+export declare const subscribersoffHandler: TwitchSlashCommand<[]>;
+export declare const slowHandler: TwitchSlashCommand<[number]>;
+export declare const slowoffHandler: TwitchSlashCommand<[]>;
+export declare const uniquechatHandler: TwitchSlashCommand<[]>;
+export declare const uniquechatoffHandler: TwitchSlashCommand<[]>;

package/backend/streaming-platforms/twitch/chat/slash-commands/moderation-handlers.d.ts

@@ -0,0 +1,8 @@
+import { TwitchSlashCommand } from "../twitch-slash-commands";
+export declare const timeoutHandler: TwitchSlashCommand<[string, number, string]>;
+export declare const banHandler: TwitchSlashCommand<[string, string]>;
+export declare const unbanHandler: TwitchSlashCommand<[string]>;
+export declare const vipHandler: TwitchSlashCommand<[string]>;
+export declare const unvipHandler: TwitchSlashCommand<[string]>;
+export declare const modHandler: TwitchSlashCommand<[string]>;
+export declare const unmodHandler: TwitchSlashCommand<[string]>;

package/backend/streaming-platforms/twitch/chat/slash-commands/twitch-command-helpers.d.ts

@@ -0,0 +1,4 @@
+export declare class TwitchSlashCommandHelpers {
+    static getRawDurationInSeconds(rawDuration: string, originalUnit?: "seconds" | "minutes" | "hours" | "days" | "weeks"): number;
+    static getNormalizedUsername(rawUsername: string): string;
+}

package/backend/streaming-platforms/twitch/chat/twitch-slash-command-handler.d.ts

@@ -0,0 +1,9 @@
+import { TwitchSlashCommandValidationResult } from './twitch-slash-commands';
+import type { TwitchApi } from '../api';
+export declare class TwitchSlashCommandHandler {
+    private _apiBase;
+    constructor(apiBase: typeof TwitchApi);
+    private _handlers;
+    validateChatCommand(message: string): TwitchSlashCommandValidationResult<unknown[]>;
+    processChatCommand(message: string, sendAsBot?: boolean): Promise<boolean>;
+}

package/backend/streaming-platforms/twitch/chatter-poll.d.ts

@@ -0,0 +1,11 @@
+declare class TwitchChatterPoll {
+    private _chatterPollIntervalId;
+    private _pollIsRunning;
+    private clearPollInterval;
+    private handleChatters;
+    runChatterPoll(): Promise<void>;
+    startChatterPoll(): void;
+    stopChatterPoll(): void;
+}
+declare const _default: TwitchChatterPoll;
+export = _default;

package/backend/streaming-platforms/twitch/effects/ad-break.d.ts

@@ -0,0 +1,5 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    adLength: number;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/announcement.d.ts

@@ -0,0 +1,7 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    color: string;
+    message: string;
+    chatter?: string;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/approve-reject-channel-reward-redemption.d.ts

@@ -0,0 +1,9 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    rewardMode?: "custom" | "current";
+    rewardId?: string;
+    redemptionMode?: "custom" | "current";
+    redemptionId?: string;
+    approve: boolean;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/block-unblock.d.ts

@@ -0,0 +1,6 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    action: "Block" | "Unblock";
+    username: string;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/cancel-prediction.d.ts

@@ -0,0 +1,3 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType;
+export = model;

package/backend/streaming-platforms/twitch/effects/create-poll.d.ts

@@ -0,0 +1,9 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    title: string;
+    choices: string[];
+    duration: number;
+    allowChannelPointVoting: boolean;
+    channelPointsPerVote: number;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/create-prediction.d.ts

@@ -0,0 +1,7 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    title: string;
+    outcomes: string[];
+    duration: number;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/create-stream-marker.d.ts

@@ -0,0 +1,5 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    description: string;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/end-poll.d.ts

@@ -0,0 +1,5 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    archivePoll: boolean;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/lock-prediction.d.ts

@@ -0,0 +1,3 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType;
+export = model;

package/backend/streaming-platforms/twitch/effects/raid.d.ts

@@ -0,0 +1,6 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    action: "Raid Channel" | "Cancel Raid";
+    username?: string;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/resolve-prediction.d.ts

@@ -0,0 +1,5 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    outcome: number;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/set-chat-mode.d.ts

@@ -0,0 +1,16 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    setFollowersOnly: boolean;
+    enableFollowersOnly?: boolean;
+    followersOnlyDuration?: string;
+    setSubscribersOnly: boolean;
+    enableSubscribersOnly?: boolean;
+    setEmoteOnly: boolean;
+    enableEmoteOnly?: boolean;
+    setSlowMode: boolean;
+    enableSlowMode?: boolean;
+    slowModeDelay?: number;
+    setUniqueChat: boolean;
+    enableUniqueChat?: boolean;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/shield-mode.d.ts

@@ -0,0 +1,5 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    action: "Enable Shield Mode" | "Disable Shield Mode";
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/shoutout.d.ts

@@ -0,0 +1,5 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    username: string;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/snooze-ad-break.d.ts

@@ -0,0 +1,3 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType;
+export = model;

package/backend/streaming-platforms/twitch/effects/stream-game.d.ts

@@ -0,0 +1,8 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    mode: "specific" | "custom" | "clear";
+    gameId: string;
+    gameName: string;
+    specificGameName?: string;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/stream-title.d.ts

@@ -0,0 +1,5 @@
+import type { EffectType } from "../../../../types/effects";
+declare const model: EffectType<{
+    title: string;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/effects/update-vip-role.d.ts

@@ -0,0 +1,6 @@
+import type { EffectType } from '../../../../types/effects';
+declare const model: EffectType<{
+    action: "Add VIP" | "Remove VIP";
+    username: string;
+}>;
+export = model;

package/backend/streaming-platforms/twitch/events/ad.d.ts

@@ -0,0 +1,2 @@
+export declare function triggerAdBreakStart(username: string, userId: string, userDisplayName: string, adBreakStart: Date, adBreakDuration: number, isAdBreakScheduled: boolean): void;
+export declare function triggerAdBreakEnd(username: string, userId: string, userDisplayName: string, adBreakDuration: number, isAdBreakScheduled: boolean): void;

package/backend/streaming-platforms/twitch/events/announcement.d.ts

@@ -0,0 +1 @@
+export declare function triggerAnnouncement(username: string, userId: string, userDisplayName: string, twitchUserRoles: string[], messageText: string, messageId: string): void;

package/backend/streaming-platforms/twitch/events/bits.d.ts

@@ -0,0 +1,7 @@
+import { EventSubChannelBitsUseMessagePart } from "../api/twurple-private-types";
+export declare function triggerCheer(username: string, userId: string, userDisplayName: string, bits: number, totalBits: number, cheerMessage: string, cheerMessageParts: EventSubChannelBitsUseMessagePart[]): void;
+export declare function triggerBitsBadgeUnlock(username: string, userId: string, userDisplayName: string, message: string, badgeTier: number): void;
+export declare function triggerPowerupMessageEffect(username: string, userId: string, userDisplayName: string, bits: number, totalBits: number, cheerMessage: string): void;
+export declare function triggerPowerupCelebration(username: string, userId: string, userDisplayName: string, bits: number, totalBits: number): void;
+export declare function triggerPowerupGigantifyEmote(username: string, userId: string, userDisplayName: string, bits: number, totalBits: number, cheerMessage: string, emoteName: string, emoteUrl: string): void;
+export declare function handleCustomPowerUpRedemption(redemptionId: string, status: string, messageText: string, userId: string, username: string, userDisplayName: string, powerUpId: string, powerUpTitle: string, powerUpPrompt: string, powerUpCost: number, powerUpImageUrl: string): void;

package/backend/streaming-platforms/twitch/events/charity.d.ts

@@ -0,0 +1,4 @@
+export declare function triggerCharityCampaignStart(charityName: string, charityDescription: string, charityLogo: string, charityWebsite: string, currentTotalAmount: number, currentTotalCurrency: string, targetTotalAmount: number, targetTotalCurrency: string): void;
+export declare function triggerCharityDonation(username: string, userId: string, userDisplayName: string, charityName: string, charityDescription: string, charityLogo: string, charityWebsite: string, donationAmount: number, donationCurrency: string): void;
+export declare function triggerCharityCampaignProgress(charityName: string, charityDescription: string, charityLogo: string, charityWebsite: string, currentTotalAmount: number, currentTotalCurrency: string, targetTotalAmount: number, targetTotalCurrency: string): void;
+export declare function triggerCharityCampaignEnd(charityName: string, charityDescription: string, charityLogo: string, charityWebsite: string, currentTotalAmount: number, currentTotalCurrency: string, targetTotalAmount: number, targetTotalCurrency: string): void;

package/backend/streaming-platforms/twitch/events/chat-message.d.ts

@@ -0,0 +1,5 @@
+import type { FirebotChatMessage } from "../../../../types/chat";
+import type { CommandDefinition, UserCommand } from "../../../../types/commands";
+export declare function triggerChatMessage(firebotChatMessage: FirebotChatMessage, triggeredCommand?: boolean, command?: CommandDefinition, userCommand?: UserCommand): void;
+export declare function triggerChatMessageDeleted(username: string, userId: string, userDisplayName: string, messageText: string, messageId: string): void;
+export declare function triggerFirstTimeChat(firebotChatMessage: FirebotChatMessage): void;

package/backend/streaming-platforms/twitch/events/chat-mode-changed.d.ts

@@ -0,0 +1 @@
+export declare function triggerChatModeChanged(chatMode: string, chatModeState: "disabled" | "enabled", moderator: string, duration?: number): void;

package/backend/streaming-platforms/twitch/events/chat.d.ts

@@ -0,0 +1,4 @@
+export declare function triggerChatCleared(username: string, userId: string): void;
+export declare function triggerSharedChatEnabled(): void;
+export declare function triggerSharedChatUpdated(): void;
+export declare function triggerSharedChatEnded(): void;

package/backend/streaming-platforms/twitch/events/follow.d.ts

@@ -0,0 +1 @@
+export declare function triggerFollow(username: string, userId: string, userDisplayName: string): void;

package/backend/streaming-platforms/twitch/events/gift-sub.d.ts

@@ -0,0 +1,3 @@
+export declare function triggerCommunitySubGift(gifterDisplayName: string, communityGiftId: string, subCount: number): void;
+export declare function triggerSubGift(gifterDisplayName: string, gifterUserName: string, gifterUserId: string, isAnonymous: boolean, gifteeDisplayName: string, subPlan: string, giftDuration: number, lifetimeGiftCount: number, communityGiftId?: string): Promise<void>;
+export declare function triggerSubGiftUpgrade(gifteeUsername: string, gifteeUserId: string, gifteeDisplayName: string, gifterDisplayName: string, subPlan: string): void;

package/backend/streaming-platforms/twitch/events/goal.d.ts

@@ -0,0 +1,4 @@
+import { EventSubChannelGoalType } from "@twurple/eventsub-base";
+export declare function triggerChannelGoalBegin(description: string, type: EventSubChannelGoalType, startDate: Date, currentAmount: number, targetAmount: number): void;
+export declare function triggerChannelGoalProgress(description: string, type: EventSubChannelGoalType, startDate: Date, currentAmount: number, targetAmount: number): void;
+export declare function triggerChannelGoalEnd(description: string, type: EventSubChannelGoalType, startDate: Date, endDate: Date, currentAmount: number, targetAmount: number, isAchieved: boolean): void;

package/backend/streaming-platforms/twitch/events/hype-train.d.ts

@@ -0,0 +1,4 @@
+import { EventSubChannelHypeTrainContribution, EventSubChannelHypeTrainType } from "@twurple/eventsub-base";
+export declare function triggerHypeTrainStart(total: number, progress: number, goal: number, level: number, startDate: Date, expiryDate: Date, topContributors: EventSubChannelHypeTrainContribution[], hypeTrainType: EventSubChannelHypeTrainType, isSharedTrain: boolean): void;
+export declare function triggerHypeTrainProgress(total: number, progress: number, goal: number, level: number, startDate: Date, expiryDate: Date, topContributors: EventSubChannelHypeTrainContribution[], hypeTrainType: EventSubChannelHypeTrainType, isSharedTrain: boolean): void;
+export declare function triggerHypeTrainEnd(total: number, level: number, startDate: Date, endDate: Date, cooldownEndDate: Date, topContributors: EventSubChannelHypeTrainContribution[], hypeTrainType: EventSubChannelHypeTrainType, isSharedTrain: boolean): void;

package/backend/streaming-platforms/twitch/events/index.d.ts

@@ -0,0 +1,50 @@
+import type { EventSource } from "../../../../types/events";
+import * as ad from "./ad";
+import * as announcement from "./announcement";
+import * as bits from "./bits";
+import * as charity from "./charity";
+import * as chat from "./chat";
+import * as chatMessage from "./chat-message";
+import * as chatModeChanged from "./chat-mode-changed";
+import * as follow from "./follow";
+import * as giftSub from "./gift-sub";
+import * as goal from "./goal";
+import * as hypeTrain from "./hype-train";
+import * as poll from "./poll";
+import * as prediction from "./prediction";
+import * as raid from "./raid";
+import * as rewardRedemption from "./reward-redemption";
+import * as shoutout from "./shoutout";
+import * as stream from "./stream";
+import * as sub from "./sub";
+import * as viewerArrived from "./viewer-arrived";
+import * as viewerBanned from "./viewer-banned";
+import * as viewerTimeout from "./viewer-timeout";
+import * as watchStreak from "./watch-streak";
+import * as whisper from "./whisper";
+export declare const TwitchEventHandlers: {
+    ad: typeof ad;
+    announcement: typeof announcement;
+    bits: typeof bits;
+    charity: typeof charity;
+    chat: typeof chat;
+    chatMessage: typeof chatMessage;
+    chatModeChanged: typeof chatModeChanged;
+    follow: typeof follow;
+    giftSub: typeof giftSub;
+    goal: typeof goal;
+    hypeTrain: typeof hypeTrain;
+    poll: typeof poll;
+    prediction: typeof prediction;
+    raid: typeof raid;
+    rewardRedemption: typeof rewardRedemption;
+    shoutout: typeof shoutout;
+    stream: typeof stream;
+    sub: typeof sub;
+    viewerArrived: typeof viewerArrived;
+    viewerBanned: typeof viewerBanned;
+    viewerTimeout: typeof viewerTimeout;
+    watchStreak: typeof watchStreak;
+    whisper: typeof whisper;
+};
+export declare const TwitchEventSource: EventSource;

package/backend/streaming-platforms/twitch/events/poll.d.ts

@@ -0,0 +1,4 @@
+import { EventSubChannelPollBeginChoice, EventSubChannelPollChoice, EventSubChannelPollEndStatus } from "@twurple/eventsub-base";
+export declare function triggerChannelPollBegin(title: string, choices: EventSubChannelPollBeginChoice[], startDate: Date, endDate: Date, isChannelPointsVotingEnabled: boolean, channelPointsPerVote: number): void;
+export declare function triggerChannelPollProgress(title: string, choices: EventSubChannelPollChoice[], startDate: Date, endDate: Date, isChannelPointsVotingEnabled: boolean, channelPointsPerVote: number): void;
+export declare function triggerChannelPollEnd(title: string, choices: EventSubChannelPollChoice[], startDate: Date, endDate: Date, isChannelPointsVotingEnabled: boolean, channelPointsPerVote: number, status: EventSubChannelPollEndStatus): void;