@crowbartools/firebot-types 5.67.0-alpha2 → 5.67.0-alpha20

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

@@ -0,0 +1,116 @@
+import { HelixChatAnnouncementColor, HelixChatChatter, HelixUserEmote } from "@twurple/api";
+import type { SharedChatParticipant } from "../../../../../types";
+import { ApiResourceBase } from "./api-resource-base";
+import type { TwitchApi } from "../";
+interface ResultWithError<TResult, TError> {
+    success: boolean;
+    result?: TResult;
+    error?: TError;
+}
+export declare class TwitchChatApi extends ApiResourceBase {
+    private _slashCommandHandler;
+    constructor(apiBase: typeof TwitchApi);
+    /**
+     * Gets the list of all chatters in the channel.
+     */
+    getAllChatters(): Promise<HelixChatChatter[]>;
+    /**
+     * Sends a chat message to the streamer's chat.
+     *
+     * @param message Chat message to send.
+     * @param replyToMessageId The ID of the message this should be replying to. Leave as null for non replies.
+     * @param sendAsBot If the chat message should be sent as the bot or not.
+     * If this is set to `false` or the bot account is not logged in, the chat message will be sent as the streamer.
+     * @returns `true` if sending the chat message was successful or `false` if it failed
+     */
+    sendChatMessage(message: string, replyToMessageId?: string, sendAsBot?: boolean): Promise<boolean>;
+    /**
+     * Sends an announcement to the streamer's chat.
+     *
+     * @param message The announcement to send
+     * @param color The color of the announcement. Options include `primary`, `blue`, `green`, `orange`, and `purple`.
+     * Defaults to `primary`, the streamer's brand color.
+     * @param sendAsBot If the announcement should be sent as the bot or not.
+     * If this is set to `false`, the announcement will be sent as the streamer.
+     * @returns `true` if the announcement was successful or `false` if it failed
+     */
+    sendAnnouncement(message: string, color?: HelixChatAnnouncementColor, sendAsBot?: boolean): Promise<boolean>;
+    /**
+     * Sends a Twitch shoutout to another channel
+     *
+     * @param targetUserId The Twitch user ID whose channel to shoutout
+     * @returns true when successful, error message string when unsuccessful
+     */
+    sendShoutout(targetUserId: string): Promise<ResultWithError<undefined, string>>;
+    /**
+     * Deletes a chat message from the streamer's chat.
+     *
+     * @param messageId The ID of the message to delete
+     * @returns `true` if the message was deleted or `false` if it failed
+     */
+    deleteChatMessage(messageId: string): Promise<boolean>;
+    /**
+     * Clears the streamer's chat.
+     *
+     * @returns `true` if chat was cleared or `false` if it failed
+     */
+    clearChat(): Promise<boolean>;
+    /**
+     * Turns emote-only mode on or off in the streamer's chat.
+     *
+     * @param enable `true` will enable emote-only mode. `false` will disable emote-only mode. Defaults to `true`.
+     * @returns `true` if the update succeeded or `false` if it failed
+     */
+    setEmoteOnlyMode(enable?: boolean): Promise<boolean>;
+    /**
+     * Turns follower-only mode on or off in the streamer's chat.
+     *
+     * @param enable `true` will enable follower-only mode. `false` will disable follower-only mode. Defaults to `true`.
+     * @param duration Duration in minutes that a user must be following the channel before they're allowed to chat. Default is `0`.
+     * @returns `true` if the update succeeded or `false` if it failed
+     */
+    setFollowerOnlyMode(enable?: boolean, duration?: number): Promise<boolean>;
+    /**
+     * Turns subscriber-only mode on or off in the streamer's chat.
+     *
+     * @param enable `true` will enable subscriber-only mode. `false` will disable subscriber-only mode. Defaults to `true`.
+     * @returns `true` if the update succeeded or `false` if it failed
+     */
+    setSubscriberOnlyMode(enable?: boolean): Promise<boolean>;
+    /**
+     * Turns slow mode on or off in the streamer's chat.
+     *
+     * @param enable `true` will enable slow mode. `false` will disable slow mode. Defaults to `true`.
+     * @param duration Duration in seconds that a user must wait between sending messages. Default is `5`.
+     * @returns `true` if the update succeeded or `false` if it failed
+     */
+    setSlowMode(enable?: boolean, duration?: number): Promise<boolean>;
+    /**
+     * Turns unique mode on or off in the streamer's chat.
+     *
+     * @param enable `true` will enable unique mode. `false` will disable unique mode. Defaults to `true`.
+     * @returns `true` if the update succeeded or `false` if it failed
+     */
+    setUniqueMode(enable?: boolean): Promise<boolean>;
+    /**
+     * Gets the chat color for a user.
+     *
+     * @param targetUserId numerical ID of the user as sting.
+     * @returns the color as hex code, null if the user did not set a color, or undefined if the user is unknown.
+     */
+    getColorForUser(targetUserId: string): Promise<string>;
+    /**
+     * Gets all emotes that can be used on Twitch by the specified Firebot account.
+     *
+     * @param account Either `streamer` or `bot`
+     * @returns An array of {@link HelixUserEmote} containing all the emotes the user can use on Twitch, or null if the request failed
+     */
+    getAllUserEmotes(account?: "streamer" | "bot"): Promise<HelixUserEmote[]>;
+    /**
+     * Gets the participants in the current shared chat session.
+     *
+     * @returns An array of {@link SharedChatParticipant} containing all the participants in the shared chat session, or null if there is no active session
+     */
+    getSharedChatParticipants(): Promise<SharedChatParticipant[]>;
+}
+export {};

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

@@ -0,0 +1,55 @@
+import { HelixClip, UserIdResolvable } from "@twurple/api";
+import { ApiResourceBase } from "./api-resource-base";
+import type { TwitchApi } from "../";
+export declare class TwitchClipsApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    /**
+     * Creates a clip in the streamer's channel
+     * @returns A {@linkcode HelixClip} representing the newly created clip
+     */
+    createClip(duration?: number, title?: string): Promise<HelixClip>;
+    /**
+     * Gets a Twitch clip from the specified clip URL
+     * @param url URL of the clip
+     * @returns A {@link HelixClip} from the given URL, or `null` if it doesn't exist
+     */
+    getClipFromClipUrl(url: string): Promise<HelixClip>;
+    /**
+     * Gets a random clip for the given user ID
+     * @param userId Twitch user ID
+     * @param limit How many clips to retrieve for random pool. Default is `100`.
+     * @param isFeatured `true` for only featured clips, `false` for only non-featured, or `undefined` for all
+     * @param startDate The earliest {@link Date} to find clips for, or `undefined` for no lower limit
+     * @param endDate The latest {@link Date} to find clips for, or `undefined` for no upper limit
+     * @returns A random {@link HelixClip} from the user's channel, or `null` if the user doesn't exist or their channel has no clips
+     */
+    getRandomClipForUserById(userId: UserIdResolvable, limit?: number, isFeatured?: boolean, startDate?: Date, endDate?: Date): Promise<HelixClip>;
+    /**
+     * Gets a random clip for the given username
+     * @param userId Twitch username
+     * @param limit How many clips to retrieve for random pool. Default is `100`.
+     * @param isFeatured `true` for only featured clips, `false` for only non-featured, or `undefined` for all
+     * @param startDate The earliest {@link Date} to find clips for, or `undefined` for no lower limit
+     * @param endDate The latest {@link Date} to find clips for, or `undefined` for no upper limit
+     * @returns A random {@link HelixClip} from the user's channel, or `null` if the user doesn't exist or their channel has no clips
+     */
+    getRandomClipForUserByName(username: string, limit?: number, isFeatured?: boolean, startDate?: Date, endDate?: Date): Promise<HelixClip>;
+    /**
+     * Get the latest clip for the given user ID.
+     *
+     * NOTE: Due to how the Twitch API works, this can take several seconds and the clip may not be the very latest.
+     * @param userId Twitch user ID
+     * @param isFeatured `true` for only featured clips, `false` for only non-featured, or `undefined` for all
+     * @returns The most recently created {@link HelixClip} from the user's channel, or `null` if the user doesn't exist or their channel has no clips
+     */
+    getLatestClipForUserById(userId: UserIdResolvable, isFeatured?: boolean): Promise<HelixClip>;
+    /**
+     * Get the latest clip for the given username.
+     *
+     * NOTE: Due to how the Twitch API works, this can take several seconds and the clip may not be the very latest.
+     * @param username Twitch username
+     * @param isFeatured `true` for only featured clips, `false` for only non-featured, or `undefined` for all
+     * @returns The most recently created {@link HelixClip} from the user's channel, or `null` if the user doesn't exist or their channel has no clips
+     */
+    getLatestClipForUserByName(username: string, isFeatured?: boolean): Promise<HelixClip>;
+}

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

@@ -0,0 +1,12 @@
+import { HelixGoal } from "@twurple/api";
+import { ApiResourceBase } from './api-resource-base';
+import type { TwitchApi } from "../";
+export declare class TwitchGoalsApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    /**
+     * Retrieves the current Twitch channel goals
+     *
+     * @returns A HelixPoll object with the most recent Twitch poll data
+     */
+    getCurrentChannelGoals(): Promise<HelixGoal[]>;
+}

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

@@ -0,0 +1,10 @@
+import { HelixHypeTrain } from "@twurple/api";
+import { ApiResourceBase } from './api-resource-base';
+import type { TwitchApi } from "../";
+export declare class TwitchHypeTrainApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    /**
+     * Retrieves current Twitch channel hype train for the streamer
+     */
+    getCurrentHypeTrain(): Promise<HelixHypeTrain>;
+}

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

@@ -0,0 +1,96 @@
+import { type HelixBan, type HelixModerator, type UserIdResolvable } from "@twurple/api";
+import type { BasicViewer } from '../../../../../types/viewers';
+import { ApiResourceBase } from './api-resource-base';
+import type { TwitchApi } from "../";
+type ModerationEvents = {
+    "vip:added": (user: BasicViewer) => void;
+    "vip:removed": (userId: string) => void;
+    "moderator:added": (user: BasicViewer) => void;
+    "moderator:removed": (userId: string) => void;
+};
+export declare class TwitchModerationApi extends ApiResourceBase<ModerationEvents> {
+    constructor(apiBase: typeof TwitchApi);
+    /**
+     * Determines if a user is timed out in the streamer's channel
+     *
+     * @param userId The user ID to check if they're timed out
+     * @returns `true` if the user is timed out, or `false` if they're either banned indefinitely or not timed out
+     */
+    isUserTimedOut(userId: UserIdResolvable): Promise<boolean>;
+    /**
+     * Times out a user in the streamer's channel for a specified duration.
+     *
+     * @param userId The Twitch user ID of the user to timeout
+     * @param duration The duration in seconds to timeout the user
+     * @param reason The reason for the timeout
+     * @returns `true` if the timeout was successful or `false` if it failed
+     */
+    timeoutUser(userId: UserIdResolvable, duration: number, reason?: string): Promise<boolean>;
+    /**
+     * Gets all banned users from a streamer's channel.
+     *
+     * @returns {HelixBan[]}
+     */
+    getBannedUsers(): Promise<HelixBan[]>;
+    /**
+     * Determines if a user is banned (not timed out) in the streamer's channel
+     *
+     * @param userId The user ID to check if they're banned
+     * @returns `true` if the user is banned, or `false` if they're either not banned or only timed out
+     */
+    isUserBanned(userId: UserIdResolvable): Promise<boolean>;
+    /**
+     * Bans a user from the streamer's channel.
+     *
+     * @param userId The Twitch user ID of the user to ban
+     * @param reason The reason for the ban
+     * @returns `true` if the ban was successful or `false` if it failed
+     */
+    banUser(userId: UserIdResolvable, reason?: string): Promise<boolean>;
+    /**
+     * Unbans/removes the timeout for a user in the streamer's channel.
+     *
+     * @param userId The Twitch user ID of the user to unban/remove from timeout
+     * @returns `true` if the unban/removal from timeout was successful or `false` if it failed
+     */
+    unbanUser(userId: UserIdResolvable): Promise<boolean>;
+    /**
+     * Gets all the moderators in the streamer's channel.
+     */
+    getModerators(): Promise<HelixModerator[]>;
+    /**
+     * Adds a moderator to the streamer's channel.
+     *
+     * @param userId The Twitch user ID of the user to add as a mod
+     * @returns `true` if the user was added as a mod successfully or `false` if it failed
+     */
+    addChannelModerator(userId: UserIdResolvable): Promise<boolean>;
+    /**
+     * Removes a moderator from the streamer's channel.
+     *
+     * @param userId The Twitch user ID of the user to remove as a mod
+     * @returns `true` if the user was removed as a mod successfully or `false` if it failed
+     */
+    removeChannelModerator(userId: UserIdResolvable): Promise<boolean>;
+    /**
+     * Adds a VIP to the streamer's channel.
+     *
+     * @param userId The Twitch user ID of the user to add as a VUP
+     * @returns `true` if the user was added as a VUP successfully or `false` if it failed
+     */
+    addChannelVip(userId: UserIdResolvable): Promise<boolean>;
+    /**
+     * Removes a VIP from the streamer's channel.
+     *
+     * @param userId The Twitch user ID of the user to remove as a VIP
+     * @returns `true` if the user was removed as a VIP successfully or `false` if it failed
+     */
+    removeChannelVip(userId: UserIdResolvable): Promise<boolean>;
+    /**
+     * Processes a message held by AutoMod.
+     * @param messageId ID of the held message
+     * @param allow `true` to allow the message, or `false` to deny it
+     */
+    processHeldAutoModMessage(messageId: string, allow: boolean): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,28 @@
+import { HelixPoll } from "@twurple/api";
+import { ApiResourceBase } from './api-resource-base';
+import type { TwitchApi } from "../";
+export declare class TwitchPollsApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    /**
+     * Creates a Twitch poll
+     *
+     * @param title Title of the poll
+     * @param choices List of choices for the poll. Minimum of 2, maximum of 5.
+     * @param duration Duration in seconds to show poll. Minimum of 15, maximum of 1800 (30 minutes).
+     * @param channelPointsPerVote Number of channel points per additional vote. If null, channel point voting will be disabled.
+     */
+    createPoll(title: string, choices: string[], duration: number, channelPointsPerVote?: number): Promise<void>;
+    /**
+     * End a Twitch poll.
+     *
+     * @param pollId The poll ID.
+     * @param showResult Whether to show the result, or archive and hide the result.
+     */
+    endPoll(pollId: string, showResult?: boolean): Promise<void>;
+    /**
+     * Retrieve the most recent Twitch poll
+     *
+     * @returns A HelixPoll object with the most recent Twitch poll data
+     */
+    getMostRecentPoll(): Promise<HelixPoll>;
+}

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

@@ -0,0 +1,21 @@
+import type { TwitchApi } from "..";
+import type { CustomReward } from "./channel-rewards";
+import { ApiResourceBase } from "./api-resource-base";
+export type CustomPowerUp = Omit<CustomReward, "cost" | "shouldRedemptionsSkipRequestQueue"> & {
+    bits: number;
+};
+export declare class TwitchPowerUpsApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    /**
+     * Get an array of custom power-ups for the streamer's channel.
+     */
+    getCustomPowerUps(): Promise<CustomPowerUp[]>;
+    /**
+     * Get a specific custom power-up by its ID.
+     * @param powerUpId The ID of the custom power-up to retrieve.
+     * @returns The custom power-up with the specified ID, or null if not found.
+     */
+    getCustomPowerUpById(powerUpId: string): Promise<CustomPowerUp | null>;
+    private fetchCustomPowerUps;
+    private mapApiCustomPowerUp;
+}

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<[]>;