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

package/backend/reconnecting-websocket/index.d.ts

@@ -0,0 +1,139 @@
+import { ClientOptions } from 'ws';
+import * as Events from './events';
+export type Event = Events.Event;
+export type ErrorEvent = Events.ErrorEvent;
+export type CloseEvent = Events.CloseEvent;
+export type Options = {
+    maxReconnectionDelay?: number;
+    minReconnectionDelay?: number;
+    reconnectionDelayGrowFactor?: number;
+    minUptime?: number;
+    connectionTimeout?: number;
+    maxRetries?: number;
+    maxEnqueuedMessages?: number;
+    startClosed?: boolean;
+    debug?: boolean;
+    wsOptions?: ClientOptions;
+};
+export type UrlProvider = string | (() => string) | (() => Promise<string>);
+export type Message = string | ArrayBuffer | Blob | ArrayBufferView;
+export type ListenersMap = {
+    error: Array<Events.WebSocketEventListenerMap['error']>;
+    message: Array<Events.WebSocketEventListenerMap['message']>;
+    open: Array<Events.WebSocketEventListenerMap['open']>;
+    close: Array<Events.WebSocketEventListenerMap['close']>;
+    ping: Array<Events.WebSocketEventListenerMap['ping']>;
+};
+export default class ReconnectingWebSocket {
+    private _ws?;
+    private _listeners;
+    private _retryCount;
+    private _uptimeTimeout;
+    private _connectTimeout;
+    private _shouldReconnect;
+    private _connectLock;
+    private _binaryType;
+    private _closeCalled;
+    private _messageQueue;
+    private readonly _url;
+    private readonly _protocols?;
+    private readonly _options;
+    constructor(url: UrlProvider, protocols?: string | string[], options?: Options);
+    static get CONNECTING(): number;
+    static get OPEN(): number;
+    static get CLOSING(): number;
+    static get CLOSED(): number;
+    get CONNECTING(): number;
+    get OPEN(): number;
+    get CLOSING(): number;
+    get CLOSED(): number;
+    get binaryType(): BinaryType;
+    set binaryType(value: BinaryType);
+    /**
+     * Returns the number or connection retries
+     */
+    get retryCount(): number;
+    /**
+     * The number of bytes of data that have been queued using calls to send() but not yet
+     * transmitted to the network. This value resets to zero once all queued data has been sent.
+     * This value does not reset to zero when the connection is closed; if you keep calling send(),
+     * this will continue to climb. Read only
+     */
+    get bufferedAmount(): number;
+    /**
+     * The extensions selected by the server. This is currently only the empty string or a list of
+     * extensions as negotiated by the connection
+     */
+    get extensions(): string;
+    /**
+     * A string indicating the name of the sub-protocol the server selected;
+     * this will be one of the strings specified in the protocols parameter when creating the
+     * WebSocket object
+     */
+    get protocol(): string;
+    /**
+     * The current state of the connection; this is one of the Ready state constants
+     */
+    get readyState(): number;
+    /**
+     * The URL as resolved by the constructor
+     */
+    get url(): string;
+    /**
+     * An event listener to be called when the WebSocket connection's readyState changes to CLOSED
+     */
+    onclose: ((event: Events.CloseEvent) => void) | null;
+    /**
+     * An event listener to be called when an error occurs
+     */
+    onerror: ((event: Events.ErrorEvent) => void) | null;
+    /**
+     * An event listener to be called when a message is received from the server
+     */
+    onmessage: ((event: MessageEvent) => void) | null;
+    /**
+     * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+     * this indicates that the connection is ready to send and receive data
+     */
+    onopen: ((event: Event) => void) | null;
+    /**
+     * Closes the WebSocket connection or connection attempt, if any. If the connection is already
+     * CLOSED, this method does nothing
+     */
+    close(code?: number, reason?: string): void;
+    /**
+     * Closes the WebSocket connection or connection attempt and connects again.
+     * Resets retry counter;
+     */
+    reconnect(code?: number, reason?: string): void;
+    /**
+     * Enqueue specified data to be transmitted to the server over the WebSocket connection
+     */
+    send(data: Message): void;
+    /**
+     * Register an event handler of a specific event type
+     */
+    addEventListener<T extends keyof Events.WebSocketEventListenerMap>(type: T, listener: Events.WebSocketEventListenerMap[T]): void;
+    dispatchEvent(event: Event): boolean;
+    /**
+     * Removes an event listener
+     */
+    removeEventListener<T extends keyof Events.WebSocketEventListenerMap>(type: T, listener: Events.WebSocketEventListenerMap[T]): void;
+    private _debug;
+    private _getNextDelay;
+    private _wait;
+    private _getNextUrl;
+    private _connect;
+    private _handleTimeout;
+    private _disconnect;
+    private _acceptOpen;
+    private _callEventListener;
+    private _handleOpen;
+    private _handleMessage;
+    private _handleError;
+    private _handlePing;
+    private _handleClose;
+    private _removeListeners;
+    private _addListeners;
+    private _clearTimeouts;
+}

package/backend/resource-token-manager.d.ts

@@ -0,0 +1,12 @@
+interface ResourceToken {
+    path: string;
+    length: number | null;
+}
+declare class ResourceTokenManager {
+    tokens: Record<string, ResourceToken>;
+    private deleteToken;
+    getResourcePath(token: string): string;
+    storeResourcePath(path: string, length: string | number | null): string;
+}
+declare const resourceTokenManager: ResourceTokenManager;
+export { resourceTokenManager as ResourceTokenManager };

package/backend/restrictions/builtin/active-chat-users.d.ts

@@ -0,0 +1,3 @@
+import type { RestrictionType } from "../../../types/restrictions";
+declare const model: RestrictionType<never>;
+export = model;

package/backend/restrictions/builtin/channel-currency.d.ts

@@ -0,0 +1,9 @@
+import type { RestrictionType } from "../../../types/restrictions";
+type ComparisonType = "less" | "greater" | "equal";
+declare const model: RestrictionType<{
+    selectedCurrency: string;
+    comparison: ComparisonType;
+    amount: number;
+    autoDeductCurrency: boolean;
+}>;
+export = model;

package/backend/restrictions/builtin/channel-game.d.ts

@@ -0,0 +1,6 @@
+import type { RestrictionType } from "../../../types/restrictions";
+declare const model: RestrictionType<{
+    gameId: string;
+    name: string;
+}>;
+export = model;

package/backend/restrictions/builtin/chat-messages.d.ts

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

package/backend/restrictions/builtin/custom-variable.d.ts

@@ -0,0 +1,6 @@
+import type { RestrictionType } from "../../../types/restrictions";
+declare const model: RestrictionType<{
+    name: string;
+    value: string;
+}>;
+export = model;

package/backend/restrictions/builtin/follow-check.d.ts

@@ -0,0 +1,8 @@
+import type { RestrictionType } from "../../../types/restrictions";
+declare const model: RestrictionType<{
+    checkMode: "streamer" | "custom";
+    value: string;
+    useFollowAge: boolean;
+    followAgeSeconds: number;
+}>;
+export = model;

package/backend/restrictions/builtin/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../../types").RestrictionType[];
+export default _default;

package/backend/restrictions/builtin/limit-per-stream.d.ts

@@ -0,0 +1,7 @@
+import type { RestrictionType } from "../../../types/restrictions";
+type RestrictionData = {
+    perUserLimit?: number;
+    globalLimit?: number;
+};
+declare const limitPerStreamRestriction: RestrictionType<RestrictionData>;
+export = limitPerStreamRestriction;

package/backend/restrictions/builtin/only-when-live.d.ts

@@ -0,0 +1,3 @@
+import type { RestrictionType } from "../../../types/restrictions";
+declare const restriction: RestrictionType;
+export = restriction;

package/backend/restrictions/builtin/permissions.d.ts

@@ -0,0 +1,13 @@
+import type { RestrictionType } from "../../../types/restrictions";
+type PermissionMode = "roles" | "viewer";
+type Rank = {
+    rankId: string;
+    ladderId: string;
+};
+declare const model: RestrictionType<{
+    mode: PermissionMode;
+    username: string;
+    roleIds: string[];
+    ranks: Rank[];
+}>;
+export = model;

package/backend/restrictions/builtin/time-range.d.ts

@@ -0,0 +1,8 @@
+import type { RestrictionType } from "../../../types/restrictions";
+declare const model: RestrictionType<{
+    mode: "time" | "days";
+    days: string[];
+    startTime: string;
+    endTime: string;
+}>;
+export = model;

package/backend/restrictions/builtin/view-time.d.ts

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

package/backend/restrictions/builtin/viewer-count.d.ts

@@ -0,0 +1,7 @@
+import type { RestrictionType } from "../../../types/restrictions";
+type ComparisonType = "less" | "greater" | "equal";
+declare const model: RestrictionType<{
+    comparison: ComparisonType;
+    amount: number;
+}>;
+export = model;

package/backend/restrictions/builtin-restrictions-loader.d.ts

@@ -0,0 +1 @@
+export declare const loadRestrictions: () => void;

package/backend/restrictions/restriction-manager.d.ts

@@ -0,0 +1,20 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { RestrictionData, RestrictionType } from "../../types/restrictions";
+import type { Trigger } from "../../types/triggers";
+type Events = {
+    "restriction-registered": (restriction: RestrictionType) => void;
+    "restriction-unregistered": (restrictionId: string) => void;
+};
+declare class RestrictionsManager extends TypedEmitter<Events> {
+    private _registeredRestrictions;
+    constructor();
+    registerRestriction(restriction: RestrictionType): void;
+    unregisterRestriction(restrictionId: string): void;
+    getRestrictionById(restrictionId: string): RestrictionType;
+    getAllRestrictions(): RestrictionType[];
+    checkPermissionsPredicateOnly(restrictionData: RestrictionData, username: string, twitchRoles: string[]): Promise<boolean>;
+    private runPredicate;
+    runRestrictionPredicates(triggerData: Trigger, restrictionData: RestrictionData, restrictionsAreInherited?: boolean): Promise<void>;
+}
+declare const manager: RestrictionsManager;
+export { manager as RestrictionsManager };

package/backend/roles/chat-roles-manager.d.ts

@@ -0,0 +1,9 @@
+declare class ChatRolesManager {
+    private _knownBots;
+    setupListeners(): void;
+    cacheViewerListBots(): Promise<void>;
+    userIsKnownBot(userId: string): Promise<boolean>;
+    getUsersChatRoles(userId: string): Promise<string[]>;
+}
+declare const chatRolesManager: ChatRolesManager;
+export = chatRolesManager;

package/backend/roles/custom-roles-manager.d.ts

@@ -0,0 +1,35 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { BasicViewer } from "../../types/viewers";
+import type { CustomRole, LegacyCustomRole } from "../../types/roles";
+type Events = {
+    "created-item": (item: object) => void;
+    "updated-item": (item: object) => void;
+    "deleted-item": (item: object) => void;
+    "viewer-role-updated": (userId: string, roleId: string, action: "added" | "removed") => void;
+};
+declare class CustomRolesManager extends TypedEmitter<Events> {
+    private _customRoles;
+    constructor();
+    migrateLegacyCustomRoles(): Promise<void>;
+    importLegacyCustomRole(legacyRole: LegacyCustomRole): Promise<void>;
+    importCustomRole(role: LegacyCustomRole | CustomRole): Promise<void>;
+    private getCustomRolesDb;
+    loadCustomRoles(): Promise<void>;
+    refreshCustomRolesUserData(): Promise<void>;
+    saveCustomRole(role: CustomRole): void;
+    addViewerToRole(roleId: string, viewer: BasicViewer): void;
+    getCustomRoles(): CustomRole[];
+    getRoleByName(name: string): CustomRole;
+    getAllCustomRolesForViewer(userId: string): {
+        id: string;
+        name: string;
+        showBadgeInChat: boolean;
+    }[];
+    userIsInRole(userId: string, userTwitchRoles: string[], roleIdsToCheck: string[]): boolean;
+    removeViewerFromRole(roleId: string, userId: string): void;
+    removeAllViewersFromRole(roleId: string): void;
+    deleteCustomRole(roleId: string): void;
+    triggerUiRefresh(): void;
+}
+declare const customRolesManager: CustomRolesManager;
+export = customRolesManager;

package/backend/roles/firebot-roles-manager.d.ts

@@ -0,0 +1,7 @@
+import type { FirebotRole } from "../../types/roles";
+declare class FirebotRolesManager {
+    private userIsInFirebotRole;
+    getAllFirebotRolesForViewer(userIdOrName: string): FirebotRole[];
+}
+declare const firebotRolesManager: FirebotRolesManager;
+export = firebotRolesManager;

package/backend/roles/role-helpers.d.ts

@@ -0,0 +1,28 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { FirebotRole } from "../../types/roles";
+export interface FirebotViewerRoles {
+    twitchRoles: FirebotRole[];
+    firebotRoles: FirebotRole[];
+    customRoles: FirebotRole[];
+    teamRoles: FirebotRole[];
+}
+type Events = {
+    "viewer-role-updated": (userId: string, roleId: string, action: "added" | "removed") => void;
+};
+declare class RoleHelpers extends TypedEmitter<Events> {
+    constructor();
+    getAllRolesForViewer(userId: string): Promise<FirebotRole[]>;
+    getAllRolesForViewerNameSpaced(userId: string): Promise<FirebotViewerRoles>;
+    viewerHasRole(userId: string, expectedRoleId: string): Promise<boolean>;
+    viewerHasRoleByName(userId: string, expectedRoleName: string): Promise<boolean>;
+    /**
+    * Check if user has the given roles by their ids
+    */
+    viewerHasRoles(userId: string, expectedRoleIds: string[]): Promise<boolean>;
+    /**
+    * Check if user has the given roles by their names
+    */
+    viewerHasRolesByName(userId: string, expectedRoleNames: string[]): Promise<boolean>;
+}
+declare const roleHelpers: RoleHelpers;
+export default roleHelpers;

package/backend/roles/team-roles-manager.d.ts

@@ -0,0 +1,10 @@
+import type { FirebotRole } from "../../types/roles";
+declare class TeamRolesManager {
+    private _streamerTeams;
+    constructor();
+    loadTeamRoles(): Promise<void>;
+    getTeamRoles(): Promise<FirebotRole[]>;
+    getAllTeamRolesForViewer(userIdOrName: string): Promise<FirebotRole[]>;
+}
+declare const teamRolesManager: TeamRolesManager;
+export = teamRolesManager;

package/backend/roles/twitch-roles-manager.d.ts

@@ -0,0 +1,31 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { BasicViewer } from "../../types/viewers";
+interface Subscriber {
+    id: string;
+    username: string;
+    displayName?: string;
+    subTier: string;
+}
+type Events = {
+    "viewer-role-updated": (userId: string, roleId: string, action: "added" | "removed") => void;
+};
+declare class TwitchRolesManager extends TypedEmitter<Events> {
+    private _vips;
+    private _moderators;
+    private _subscribers;
+    constructor();
+    setupListeners(): void;
+    loadVips(): Promise<void>;
+    getVips(): BasicViewer[];
+    addVipToVipList(viewer: BasicViewer): void;
+    removeVipFromVipList(userId: string): void;
+    loadModerators(): Promise<void>;
+    getModerators(): BasicViewer[];
+    addModeratorToModeratorsList(viewer: BasicViewer): void;
+    removeModeratorFromModeratorsList(userId: string): void;
+    loadSubscribers(): Promise<void>;
+    getSubscribers(): Subscriber[];
+    private getRoleForSubTier;
+}
+declare const twitchRolesManager: TwitchRolesManager;
+export = twitchRolesManager;

package/backend/script-log-names.d.ts

@@ -0,0 +1,3 @@
+export declare function registerScriptLogName(scriptId: string, displayName: string): void;
+export declare function unregisterScriptLogName(scriptId: string): void;
+export declare function getScriptLogName(scriptId: string): string | undefined;

package/backend/secrets-manager.d.ts

@@ -0,0 +1,16 @@
+interface FirebotSecrets {
+    twitchClientId: string;
+    tipeeeStreamClientId: string;
+    tipeeeStreamClientSecret: string;
+    streamLabsClientId: string;
+    streamLabsClientSecret: string;
+    fontAwesome5KitId: string;
+}
+declare class SecretsManager {
+    secrets: FirebotSecrets;
+    expectedKeys: (keyof FirebotSecrets)[];
+    constructor();
+    testSecrets(): boolean;
+}
+declare const secretsManager: SecretsManager;
+export { secretsManager as SecretsManager };

package/backend/setups/setup-manager.d.ts

@@ -0,0 +1,19 @@
+import type { FirebotSetup } from "../../types/setups";
+export interface LoadSetupResult {
+    success: boolean;
+    setup?: FirebotSetup;
+    error?: string;
+}
+declare class SetupManager {
+    constructor();
+    setupListeners(): void;
+    private loadSetup;
+    private createSetup;
+    private findAndReplaceCurrency;
+    private replaceQuestionAnswers;
+    private replaceCurrency;
+    private importSetup;
+    private removeSetupComponents;
+}
+declare const manager: SetupManager;
+export { manager as SetupManager };

package/backend/sort-tags/sort-tag-manager.d.ts

@@ -0,0 +1,16 @@
+import type { SortTag } from "../../types/sort-tags";
+interface SortTagCache {
+    [context: string]: SortTag[];
+}
+declare class SortTagManager {
+    sortTags: SortTagCache;
+    constructor();
+    getSortTagsDb(): import("node-json-db/dist/JsonDB").JsonDB;
+    loadSortTags(): void;
+    private getLegacyEventAndCommandTags;
+    saveSortTagsForContext(context: string, sortTags: SortTag[]): void;
+    getSortTagsForContext(context: string): SortTag[];
+    private saveAllSortTags;
+}
+declare const sortTagManager: SortTagManager;
+export { sortTagManager as SortTagManager };

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

@@ -0,0 +1,17 @@
+declare class AdManager {
+    private _adCheckIntervalId;
+    private _nextAdBreak;
+    private _isAdCheckRunning;
+    private _upcomingEventTriggered;
+    private _isAdRunning;
+    constructor();
+    get secondsUntilNextAdBreak(): number;
+    get isAdBreakRunning(): boolean;
+    runAdCheck(): Promise<void>;
+    triggerAdBreakStart(duration: number, endsAt: Date): void;
+    triggerAdBreakComplete(): void;
+    startAdCheck(): Promise<void>;
+    stopAdCheck(): void;
+}
+declare const adManager: AdManager;
+export = adManager;

package/backend/streaming-platforms/twitch/api/eventsub/custom-subscriptions/power-up-redemption-add-subscription.d.ts

@@ -0,0 +1,30 @@
+import type { HelixEventSubSubscription } from "@twurple/api";
+import { EventSubSubscription, EventSubBase } from "@twurple/eventsub-base";
+type EventData = {
+    id: string;
+    broadcaster_user_id: string;
+    broadcaster_user_login: string;
+    broadcaster_user_name: string;
+    user_id: string;
+    user_login: string;
+    user_name: string;
+    user_input: string;
+    status: string;
+    custom_power_up: {
+        id: string;
+        title: string;
+        bits_cost: number;
+        prompt: string;
+    };
+    redeemed_at: string;
+};
+export declare class EventSubPowerUpRedemptionAddSubscription extends EventSubSubscription<EventData> {
+    private readonly _broadcasterId;
+    readonly _cliName = "power-up-redemption-add";
+    constructor(handler: (data: EventData) => void, client: EventSubBase, _broadcasterId: string);
+    get id(): string;
+    get authUserId(): string | null;
+    protected transformData(data: EventData): EventData;
+    protected _subscribe(): Promise<HelixEventSubSubscription>;
+}
+export {};

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

@@ -0,0 +1,68 @@
+import type { HelixChatBadgeSet, HelixCheermoteList, HelixEmoteScale } from "@twurple/api";
+import { type EventSubAutoModMessageHoldV2Event, type EventSubChannelChatNotificationEvent, type EventSubUserWhisperMessageEvent, EventSubChannelChatMessageEvent } from "@twurple/eventsub-base";
+import type { FirebotChatMessage } from "../../../../../types/chat";
+import { ThirdPartyEmote } from "../../../../chat/third-party/third-party-emote-provider";
+export interface ChatBadge {
+    title: string;
+    url: string;
+}
+interface HelixEmoteBase {
+    id: string;
+    name: string;
+    getStaticImageUrl(scale?: HelixEmoteScale): string;
+    getAnimatedImageUrl(scale?: HelixEmoteScale): string;
+}
+declare class TwitchEventSubChatHelpers {
+    private readonly CHAT_ACTION_REGEX;
+    private readonly URL_REGEX;
+    readonly HIGHLIGHT_MESSAGE_REWARD_ID = "highlight-message";
+    private _badgeCache;
+    private _colorCache;
+    private _getAllTwitchEmotes;
+    private _twitchEmotes;
+    private _thirdPartyEmotes;
+    private _thirdPartyEmoteProviders;
+    private _twitchCheermotes;
+    private _profilePicUrlCache;
+    constructor();
+    get badges(): HelixChatBadgeSet[];
+    get twitchEmotes(): {
+        streamer: HelixEmoteBase[];
+        bot: HelixEmoteBase[];
+    };
+    get thirdPartyEmotes(): ThirdPartyEmote[];
+    get twitchCheermotes(): HelixCheermoteList;
+    cacheBadges(): Promise<void>;
+    cacheTwitchEmotes(): Promise<void>;
+    cacheThirdPartyEmotes(): Promise<void>;
+    cacheCheermotes(): Promise<void>;
+    cacheChatAssets(): Promise<void>;
+    private _mapCachedEmotesForFrontend;
+    private getEmoteUrl;
+    private accountTaggedInText;
+    private parseMessageParts;
+    private parseEmote;
+    private parseEventSubEmote;
+    private parseCheermote;
+    private parseEventSubCheermote;
+    private parseFirebotCheermote;
+    private parseEventSubMention;
+    private parseChatBadges;
+    private updateAccountAvatar;
+    getUserProfilePicUrl(userId: string): Promise<string>;
+    setUserProfilePicUrl(userId: string, url: string, updateAccountAvatars?: boolean): void;
+    cacheUserColor(userId: string, color?: string | null): string;
+    /**
+     * Parses out any control characters from a chat message (like ACTION when /me is used)
+     * @param rawText Raw message text
+     * @returns Chat message text, stripped of control characters
+     */
+    private getChatMessage;
+    private buildBaseChatMessage;
+    buildChatMessageFromChatEvent(event: EventSubChannelChatMessageEvent | EventSubChannelChatNotificationEvent): Promise<FirebotChatMessage>;
+    buildFirebotChatMessageFromWhisper(message: EventSubUserWhisperMessageEvent): Promise<FirebotChatMessage>;
+    buildChatMessageFromAutoModEvent(event: EventSubAutoModMessageHoldV2Event): Promise<FirebotChatMessage>;
+    enrichMessageWithRanksAndRoles(firebotChatMessage: FirebotChatMessage): Promise<void>;
+}
+declare const chatHelpers: TwitchEventSubChatHelpers;
+export { chatHelpers as TwitchEventSubChatHelpers };

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

@@ -0,0 +1,10 @@
+declare class TwitchEventSubClient {
+    private _eventSubListener;
+    private _subscriptions;
+    private createSubscriptions;
+    createClient(): void;
+    removeSubscriptions(): void;
+    disconnectEventSub(): void;
+}
+declare const client: TwitchEventSubClient;
+export { client as TwitchEventSubClient };

package/backend/streaming-platforms/twitch/api/eventsub/eventsub-helpers.d.ts

@@ -0,0 +1,7 @@
+import type { EventSubChannelRewardEvent, EventSubChannelSharedChatSessionParticipant } from "@twurple/eventsub-base";
+import type { SharedChatParticipant } from "../../../../../types";
+import type { CustomReward } from "../resource/channel-rewards";
+import { CustomPowerUp } from "../resource/power-ups";
+export declare function mapEventSubRewardToTwitchData(event: EventSubChannelRewardEvent): CustomReward;
+export declare function getChannelRewardOrPowerUpImageUrl(rewardOrPowerUp: CustomReward | CustomPowerUp): string;
+export declare function mapSharedChatParticipants(participants: EventSubChannelSharedChatSessionParticipant[]): Promise<SharedChatParticipant[]>;