@crowbartools/firebot-types 5.67.0-alpha26 → 5.67.0-alpha28

package/backend/chat/active-user-handler.d.ts

@@ -27,12 +27,17 @@ type Events = {
     "user:offline": (userId: string) => void;
 };
 declare class ActiveUserHandler extends TypedEmitter<Events> {
-    private logger;
+    private _logger;
+    private _cachedFrontendViewers;
     private readonly DEFAULT_ACTIVE_TIMEOUT;
     private readonly ONLINE_TIMEOUT;
     private _onlineUsers;
     private _activeUsers;
     constructor();
+    private sendViewerUpdateToFrontend;
+    private updateViewerActiveStatus;
+    updateOnlineViewerRoles(userId: string, roles: string[]): void;
+    private setUserOffline;
     /**
      * Check if user is active
      * @param usernameOrId Twitch username or user ID
@@ -50,6 +55,7 @@ declare class ActiveUserHandler extends TypedEmitter<Events> {
     addActiveUser(chatUser: ChatUser, includeInOnline?: boolean, forceActive?: boolean): Promise<void>;
     removeActiveUser(usernameOrId: string | number): void;
     clearAllActiveUsers(): void;
+    triggerUiRefresh(): void;
 }
 declare const handler: ActiveUserHandler;
 export { handler as ActiveUserHandler };

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

@@ -0,0 +1,36 @@
+import type { DashboardChatFeedPowerUpData, DashboardChatFeedRewardData, FirebotChatMessage } from "../../types";
+declare class FrontendChatManager {
+    private _logger;
+    private _chatFeedCache;
+    private _chatFeedCacheLimit;
+    private _pendingOverlayMessageCache;
+    constructor();
+    private addNewChatFeedItem;
+    private sendUpdatedFeedItemToDashboard;
+    sendAlertToDashboard(message: string, icon?: string): void;
+    sendRewardRedemptionToDashboard(redemption: DashboardChatFeedRewardData): void;
+    sendPowerUpRedemptionToDashboard(redemption: DashboardChatFeedPowerUpData): void;
+    private sendChatMessageToDashboard;
+    private sendChatMessageToChatWidget;
+    sendChatMessageToFrontend(chatMessage: FirebotChatMessage): void;
+    private deleteChatMessageFromDashboard;
+    private deleteChatMessageFromChatWidget;
+    deleteChatMessageFromFrontend(messageId: string, animate?: boolean): void;
+    private deleteUserMessagesFromDashboard;
+    deleteUserMessagesFromFrontend(username: string): void;
+    private clearDashboardChatFeed;
+    clearChatFeed(moderatorUsername: string): void;
+    private expireAutomodForChatMessage;
+    updateChatMessageAutomodStatus(messageId: string, newStatus: FirebotChatMessage["autoModStatus"], resolverName: string): void;
+    setChatMessageAutomodError(messageId: string, likelyExpired: boolean): void;
+    addCustomHighlightToDashboardChatMessage(highlightData: {
+        messageId: string;
+        customHighlightColor: string;
+        customBannerIcon: string;
+        customBannerText: string;
+    }): void;
+    hideChatMessageFromDashboard(messageId: string): void;
+    triggerUiRefresh(): void;
+}
+declare const manager: FrontendChatManager;
+export { manager as FrontendChatManager };

package/backend/common/connection-manager.d.ts

@@ -0,0 +1,40 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { HelixStream } from "@twurple/api";
+import { ConnectionState } from "../../shared/connection-constants";
+type ServiceConnectionEventData = {
+    serviceId: string;
+    connectionState: ConnectionState;
+};
+type ServiceConnectionUpdateRequest = {
+    id: string;
+    action: boolean | "toggle";
+};
+type ConnectionManagerEvents = {
+    "streamerOnlineChange": (isOnline: boolean, stream: HelixStream) => void;
+    "service-connection-update": (event: ServiceConnectionEventData) => void;
+};
+declare class ConnectionManager extends TypedEmitter<ConnectionManagerEvents> {
+    private _logger;
+    private _currentStream;
+    private _onlineCheckIntervalId;
+    private _serviceConnectionStates;
+    private _connectionUpdateInProgress;
+    private _currentlyWaitingService;
+    constructor();
+    private onServiceConnectionUpdated;
+    private checkOnline;
+    startOnlineCheckInterval(): void;
+    get streamerIsOnline(): boolean;
+    get currentStream(): HelixStream | null;
+    get chatIsConnected(): boolean;
+    serviceIsConnected(serviceId: string): boolean;
+    private connectSidebarControlledServices;
+    private disconnectSidebarControlledServices;
+    updateChatConnection(shouldConnect: boolean): boolean;
+    updateIntegrationConnection(integrationId: string, shouldConnect: boolean): boolean;
+    updateServiceConnection(serviceId: string, shouldConnect: boolean): boolean;
+    updateConnectionForServices(services: ServiceConnectionUpdateRequest[]): Promise<void>;
+    triggerUiRefresh(): void;
+}
+declare const manager: ConnectionManager;
+export { manager as ConnectionManager };

package/backend/common/profile-manager.d.ts

@@ -17,6 +17,9 @@ declare class ProfileManager {
     deletePathInProfile(filePath: string): void;
     getNewProfileName: () => string;
     hasProfileRename: () => boolean;
+    private getAccountInfo;
+    private getProfileDataForFrontend;
+    triggerUiRefresh(): void;
 }
 declare const manager: ProfileManager;
 export { manager as ProfileManager };

package/backend/core/update-manager.d.ts

@@ -0,0 +1,16 @@
+declare class UpdateManager {
+    private _logger;
+    private _octokit;
+    private _isCheckingForUpdates;
+    private _hasCheckedForUpdates;
+    private _updateDownloaded;
+    private _updateData;
+    constructor();
+    private shouldAutoUpdate;
+    private checkForUpdate;
+    private downloadUpdate;
+    private installUpdate;
+    triggerUiRefresh(): void;
+}
+declare const manager: UpdateManager;
+export { manager as UpdateManager };

package/backend/currency/currency-manager.d.ts

@@ -24,6 +24,7 @@ declare class CurrencyManager {
     adjustCurrencyForAllViewers(currencyId: string, value: string | number, ignoreDisable?: boolean, adjustType?: string): Promise<void>;
     addCurrencyToAllViewers(currencyId: string, value: number): Promise<void>;
     getViewerCurrencyAmount(username: string, currencyId: string): Promise<number>;
+    getViewerCurrencyAmountByUserId(userId: string, currencyId: string): Promise<number>;
     getViewerCurrencies(usernameOrId: string, isUsername?: boolean): Promise<Record<string, number>>;
     getViewerCurrencyRank(currencyId: string, usernameOrId: string, isUsername?: boolean): Promise<number>;
     getTopCurrencyPosition(currencyId: string, position?: number): Promise<FirebotViewer>;

package/backend/effects/builtin/overlay-widgets/update-rotating-text.d.ts

@@ -0,0 +1,12 @@
+import type { EffectType } from "../../../../types";
+declare const model: EffectType<{
+    rotatingTextWidgetId: string;
+    action: "add" | "remove" | "set";
+    texts?: string[];
+    variableEvaluation?: "dynamic" | "onRun";
+    removeMode?: "first" | "last" | "position" | "matching";
+    removePosition?: number;
+    removeValue?: string;
+    removeExactMatch?: boolean;
+}>;
+export = model;

package/backend/events/activity-feed-manager.d.ts

@@ -1,9 +1,11 @@
 import type { EventDefinition } from "../../types";
 declare class ActivityFeedManager {
+    private _previousActivity;
+    private _logger;
     isUSLocale: boolean;
     timeFormat: string;
-    private _previousActivity;
     constructor();
+    private formatActivityForFrontend;
     handleTriggeredEvent(source: {
         id: string;
         name: string;
@@ -13,6 +15,11 @@ declare class ActivityFeedManager {
     }): void;
     retriggerLastActivity(): void;
     private retriggerActivity;
+    private toggleActivityAcknowledged;
+    updateAcknowledgedForAll(acknowledged: boolean): void;
+    private toggleAcknowledgedForAll;
+    private clearAllActivities;
+    triggerUiRefresh(): void;
 }
 declare const manager: ActivityFeedManager;
 export { manager as ActivityFeedManager };

package/backend/events/event-manager.d.ts

@@ -20,7 +20,7 @@ declare class EventManager extends TypedEmitter<{
     getEventById(sourceId: string, eventId: string): EventDefinition;
     getAllEventSources(): RegisteredEventSource[];
     getAllEvents(): EventDefinition[];
-    triggerEvent(eventSourceId: string, eventId: string, meta: Record<string, unknown>, isManual?: boolean, isRetrigger?: boolean, isSimulation?: boolean): Promise<void>;
+    triggerEvent(eventSourceId: string, eventId: string, meta?: Record<string, unknown>, isManual?: boolean, isRetrigger?: boolean, isSimulation?: boolean): Promise<void>;
 }
 declare const manager: EventManager;
 export { manager as EventManager };

package/backend/overlay-widgets/builtin-types/index.d.ts

@@ -1,4 +1,4 @@
-declare const _default: (import("../../../types").OverlayWidgetType<{
+declare const _default: (import("../../../types").OverlayWidgetType<import("./chat/chat").ChatWidgetSettings, import("./chat/chat").ChatWidgetState> | import("../../../types").OverlayWidgetType<import("./chat/chat-advanced").AdvancedChatWidgetSettings, import("./chat/chat").ChatWidgetState> | import("../../../types").OverlayWidgetType<{
     title?: string;
     titleFontOptions?: import("../../../types").FontOptions;
     barColor: string;
@@ -28,7 +28,7 @@ declare const _default: (import("../../../types").OverlayWidgetType<{
     fontOptions?: import("../../../types").FontOptions;
     horizontalAlignment: "left" | "center" | "right";
     verticalAlignment: "top" | "center" | "bottom";
-}, {}> | import("../../../types").OverlayWidgetType<{
+}, {}> | import("../../../types").OverlayWidgetType<import("./rotating-text/rotating-text").RotatingTextSettings, import("./rotating-text/rotating-text").RotatingTextState> | import("../../../types").OverlayWidgetType<{
     format?: string;
     fontOptions?: import("../../../types").FontOptions;
     horizontalAlignment: "left" | "center" | "right";
@@ -44,5 +44,5 @@ declare const _default: (import("../../../types").OverlayWidgetType<{
     imageType: "local" | "url";
     filepath: string;
     url: string;
-}, {}> | import("../../../types").OverlayWidgetType<import("./chat/chat").ChatWidgetSettings, import("./chat/chat").ChatWidgetState> | import("../../../types").OverlayWidgetType<import("./chat/chat-advanced").AdvancedChatWidgetSettings, import("./chat/chat").ChatWidgetState> | import("../../../types").OverlayWidgetType<import("./twitch-poll/twitch-poll").PollSettings, import("./twitch-poll/twitch-poll").PollState> | import("../../../types").OverlayWidgetType<import("./twitch-prediction/twitch-prediction").PredictionSettings, import("./twitch-prediction/twitch-prediction").PredictionState>)[];
+}, {}> | import("../../../types").OverlayWidgetType<import("./twitch-poll/twitch-poll").PollSettings, import("./twitch-poll/twitch-poll").PollState> | import("../../../types").OverlayWidgetType<import("./twitch-prediction/twitch-prediction").PredictionSettings, import("./twitch-prediction/twitch-prediction").PredictionState>)[];
 export default _default;

package/backend/overlay-widgets/builtin-types/rotating-text/rotating-text.d.ts

@@ -0,0 +1,18 @@
+import type { OverlayWidgetType, OverlayWidgetConfig, FontOptions, Animation } from "../../../../types";
+export declare const ROTATING_TEXT_TYPE_ID = "firebot:rotating-text";
+export type RotatingTextSettings = {
+    texts: string[];
+    intervalSeconds: number;
+    randomizeOrder: boolean;
+    fontOptions?: FontOptions;
+    horizontalAlignment: "left" | "center" | "right";
+    verticalAlignment: "top" | "center" | "bottom";
+    backgroundColor: string;
+    backgroundBorderRadius: number;
+    addDropShadow: boolean;
+    textEnterAnimation: Animation;
+    textExitAnimation: Animation;
+};
+export type RotatingTextState = Record<string, never>;
+export type RotatingTextWidgetConfig = OverlayWidgetConfig<RotatingTextSettings, RotatingTextState>;
+export declare const rotatingText: OverlayWidgetType<RotatingTextSettings, RotatingTextState>;

package/backend/plugins/executors/plugin-executor.interface.d.ts

@@ -1,4 +1,4 @@
-import { InstalledPluginConfig, LegacyCustomScript, PluginBase, Awaitable, PluginDetails, AdditionalVariableEvent, AdditionalEffectEvent } from "../../../types";
+import { InstalledPluginConfig, LegacyCustomScript, PluginBase, Awaitable, PluginDetails, AdditionalVariableEvent, AdditionalEffectEvent, AdditionalFilterEvent } from "../../../types";
 import type { PluginApiContext } from "../plugin-api";
 declare abstract class IBasePluginExecutor {
     abstract canHandle(plugin: PluginBase | LegacyCustomScript): Awaitable<boolean>;
@@ -24,6 +24,7 @@ export interface PluginRegistrations {
     websocketListenerName?: string;
     additionalVariableEvents?: AdditionalVariableEvent[];
     additionalEffectEvents?: AdditionalEffectEvent[];
+    additionalFilterEvents?: AdditionalFilterEvent[];
 }
 export type PluginExecutionResult = {
     success: true;

package/backend/plugins/plugin-api/namespaces/currency.d.ts

@@ -0,0 +1,2 @@
+import type { PluginCurrencyApi } from "../../../../types/plugin-api";
+export declare const createCurrencyApi: import("../internal/define-namespace").PluginApiNamespaceFactory<PluginCurrencyApi>;

package/backend/plugins/plugin-api/namespaces/viewers.d.ts

@@ -0,0 +1,2 @@
+import type { PluginViewersApi } from "../../../../types/plugin-api";
+export declare const createViewersApi: import("../internal/define-namespace").PluginApiNamespaceFactory<PluginViewersApi>;

package/backend/plugins/plugin-manager.d.ts

@@ -9,15 +9,26 @@ type GetPluginDetailsResult = {
     success: false;
     error: string;
 };
+type PluginInstallResult = {
+    success: true;
+    installedPlugin: InstalledPlugin;
+} | {
+    success: false;
+    error: string;
+};
 declare class PluginManager {
+    private _logger;
     private startingPlugins;
     private activePlugins;
+    private updateCheckInterval;
+    private pendingUpdates;
     private pendingApiInstances;
     private requireInterceptorInstalled;
     private pluginExecutors;
     private legacyEffectScriptExecutor;
     constructor();
     migrateLegacyStartUpScriptsToPlugins(): Promise<void>;
+    triggerUiRefresh(): Promise<void>;
     startPlugin(pluginConfig: InstalledPluginConfig, installing?: boolean): Promise<void>;
     private doStartPlugin;
     startPlugins(): Promise<void>;
@@ -32,7 +43,7 @@ declare class PluginManager {
      * Handle a config change. Starts/stops as needed, and on a still-enabled plugin
      * either re-loads (if file may have changed) or invokes onParameterUpdate.
      */
-    reloadPluginConfig(pluginConfig: InstalledPluginConfig, isNewInstall?: boolean): Promise<void>;
+    reloadPluginConfig(pluginConfig: InstalledPluginConfig): Promise<void>;
     setPluginEnabled(pluginId: string, enabled: boolean): Promise<void>;
     getInstalledPlugins(): Promise<InstalledPlugin[]>;
     private doGetPluginDetailsByFileName;
@@ -45,16 +56,11 @@ declare class PluginManager {
      * Validates a file at any path on disk and copies it into the scripts folder.
      * Does NOT persist an InstalledPluginConfig — caller does that on save.
      */
-    installPluginFromPath(sourcePath: string, overwrite?: boolean): Promise<GetPluginDetailsResult | {
+    installPluginFromPath(sourcePath: string, overwrite?: boolean): Promise<PluginInstallResult | {
         success: false;
         error: string;
         conflict?: boolean;
     }>;
-    /**
-     * Delete a copied plugin file that the user cancelled installing, but only
-     * when no config currently references it.
-     */
-    cancelInstall(fileName: string): Promise<void>;
     /**
      * Called by PluginConfigManager when a config is deleted, so we can stop the
      * plugin.
@@ -94,6 +100,12 @@ declare class PluginManager {
      */
     private loadPluginIsolated;
     private isValidPlugin;
+    private searchForCommunityPlugins;
+    private downloadAndSaveCommunityPlugin;
+    private installCommunityPlugin;
+    private updateCommunityPlugin;
+    startCommunityPluginUpdateCheck(): void;
+    private checkForCommunityPluginUpdates;
 }
 declare const pluginManager: PluginManager;
 export { pluginManager as PluginManager };

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

@@ -13,6 +13,7 @@ declare class TwitchRolesManager extends TypedEmitter<Events> {
     private _vips;
     private _moderators;
     private _subscribers;
+    private _subscribersLastLoadedAt;
     constructor();
     setupListeners(): void;
     loadVips(): Promise<void>;
@@ -24,7 +25,10 @@ declare class TwitchRolesManager extends TypedEmitter<Events> {
     addModeratorToModeratorsList(viewer: BasicViewer): void;
     removeModeratorFromModeratorsList(userId: string): void;
     loadSubscribers(): Promise<void>;
+    private getMinutesSinceSubscribersLoaded;
     getSubscribers(): Subscriber[];
+    addSubscriberToSubscribersList(userId: string, username: string, displayName: string, tier: string): void;
+    removeSubscriberFromSubscribersList(userId: string): void;
     private getRoleForSubTier;
 }
 declare const twitchRolesManager: TwitchRolesManager;

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

@@ -38,6 +38,7 @@ declare class TwitchEventSubChatHelpers {
     cacheThirdPartyEmotes(): Promise<void>;
     cacheCheermotes(): Promise<void>;
     cacheChatAssets(): Promise<void>;
+    private sendAllEmotesToFrontend;
     private _mapCachedEmotesForFrontend;
     private getEmoteUrl;
     private accountTaggedInText;

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

@@ -2,6 +2,7 @@ declare class TwitchEventSubClient {
     private logger;
     private _eventSubListener;
     private _subscriptions;
+    private ensureViewerExists;
     private createSubscriptions;
     createClient(): void;
     removeSubscriptions(): void;

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

@@ -1,5 +1,5 @@
 import { type HelixBan, type HelixModerator, type UserIdResolvable } from "@twurple/api";
-import type { BasicViewer } from '../../../../../types/viewers';
+import type { BasicViewer } from '../../../../../types';
 import { ApiResourceBase } from './api-resource-base';
 import type { TwitchApi } from "../";
 type ModerationEvents = {

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

@@ -1,4 +1,4 @@
-import { EventSubChannelBitsUseMessagePart } from "../api/twurple-private-types";
+import type { 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;

package/backend/ui-extensions/ui-extension-manager.d.ts

@@ -2,10 +2,12 @@ import type { UIExtension } from "../../types";
 declare class UIExtensionManager {
     private _logger;
     private _extensions;
+    private _pendingRemovals;
+    private _pendingRegistrations;
     private uiReady;
-    constructor();
     registerUIExtension(extension: UIExtension, pluginId?: string): boolean;
-    private setUIReadyForExtensions;
+    queueUIExtensionRemoval(extensionId: string): void;
+    setUIReadyForExtensions(): void;
     private prepareExtensionForFrontend;
     private prepareFunc;
 }

package/backend/utils/index.d.ts

@@ -14,3 +14,4 @@ export { pick } from "./pick";
 export { stringify } from "./stringify";
 export { getEventIdFromTriggerData } from "./trigger-data";
 export { getUrlRegex } from "./url";
+export { meetsFirebotVersionRequirement } from "./versions";

package/backend/utils/versions.d.ts

@@ -0,0 +1,9 @@
+import type { ManifestFirebotVersion } from "../../types";
+/**
+ * Checks whether a given Firebot version meets the provided minimum and/or maximum version spec
+ * @param current Current Firebot version
+ * @param min Minimum required Firebot version
+ * @param max Maximum compatible Firebot version
+ * @returns `true` if the supplied current version is within the constraints, or `false` if not
+ */
+export declare const meetsFirebotVersionRequirement: (current: ManifestFirebotVersion, min?: ManifestFirebotVersion, max?: ManifestFirebotVersion) => boolean;

package/backend/viewers/viewer-database.d.ts

@@ -1,6 +1,6 @@
 import { TypedEmitter } from "tiny-typed-emitter";
 import Datastore from "@seald-io/nedb";
-import type { BasicViewer, FirebotViewer, NewFirebotViewer, Rank, RankLadder } from "../../types";
+import type { BasicViewer, FirebotViewer, FrontendViewer, NewFirebotViewer, Rank, RankLadder } from "../../types";
 interface ViewerDbChangePacket {
     userId: string;
     field: string;
@@ -40,6 +40,7 @@ interface UserDetails {
     twitchData: Record<string, unknown>;
     streamerFollowsUser: boolean;
     userFollowsStreamer: boolean;
+    pronouns: string;
 }
 declare class ViewerDatabase extends TypedEmitter<{
     "viewer-database-loaded": () => void;
@@ -47,6 +48,7 @@ declare class ViewerDatabase extends TypedEmitter<{
         userId: string;
         url: string;
     }) => void;
+    "frontend-viewer-updated": (viewer: FrontendViewer) => void;
 }> {
     private logger;
     private _db;

package/backend/viewers/viewer-metadata-manager.d.ts

@@ -9,10 +9,13 @@ declare class ViewerMetadataManager extends TypedEmitter<Events> {
     private logger;
     constructor();
     getViewerMetadata(username: string, key: string, propertyPath: string): Promise<unknown>;
+    getViewerMetadataByUserId(userId: string, key: string, propertyPath?: string): Promise<unknown>;
     getTopMetadataPosition(metadataKey: string, position?: number): Promise<FirebotViewer>;
     getTopMetadata(metadataKey: string, count: number): Promise<FirebotViewer[]>;
     updateViewerMetadata(username: string, key: string, value: string, propertyPath?: string): Promise<void>;
+    setViewerMetadataByUserId(userId: string, key: string, value: string, propertyPath?: string): Promise<void>;
     removeViewerMetadata(username: string, key: string): Promise<void>;
+    deleteViewerMetadataByUserId(userId: string, key: string): Promise<void>;
 }
 declare const viewerMetadataManager: ViewerMetadataManager;
 export = viewerMetadataManager;

package/backend/viewers/viewer-online-status-manager.d.ts

@@ -1,6 +1,6 @@
 import type { BasicViewer, FirebotViewer } from "../../types";
 declare class ViewerOnlineStatusManager {
-    private logger;
+    private _logger;
     private _updateLastSeenIntervalId;
     private _updateTimeIntervalId;
     constructor();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowbartools/firebot-types",
-  "version": "5.67.0-alpha26",
+  "version": "5.67.0-alpha28",
   "description": "Type definitions and plugin API for Firebot plugins.",
   "main": "index.js",
   "types": "index.d.ts",

package/server/http-server-manager.d.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from "events";
 import { Express, Request, Response, Router } from "express";
 import http from "http";
-import type { HttpMethod, CustomHttpRoute, PluginHttpRouteDefinition, CustomWebSocketHandler, Awaitable } from "../types";
+import type { HttpMethod, CustomHttpRoute, PluginHttpRouteDefinition, PluginWebSocketHandler, Awaitable } from "../types";
 interface ServerInstance {
     name: string;
     port: number;
@@ -63,7 +63,7 @@ declare class HttpServerManager extends EventEmitter {
     };
     private getCustomRoutePathFromRoot;
     private removeCustomRoute;
-    registerCustomWebSocketListener(pluginName: string, handler: CustomWebSocketHandler["handler"]): boolean;
+    registerCustomWebSocketListener(pluginName: string, handler: PluginWebSocketHandler["handler"]): boolean;
     unregisterCustomWebSocketListener(pluginName: string): boolean;
 }
 declare const manager: HttpServerManager;

package/server/websocket-server-manager.d.ts

@@ -1,11 +1,12 @@
 import { EventEmitter } from "events";
 import http from "http";
-import type { CustomWebSocketHandler, WidgetOverlayEvent } from "../types";
+import type { PluginWebSocketHandler, WidgetOverlayEvent, OverlayRequestWebSocketHandler } from "../types";
 declare class WebSocketServerManager extends EventEmitter {
     private logger;
     overlayHasClients: boolean;
     private server;
-    private customHandlers;
+    private pluginHandlers;
+    private overlayRequestHandlers;
     constructor();
     createServer(httpServer: http.Server): void;
     sendToOverlay(eventName: string, meta?: Record<string, unknown>, overlayInstance?: string): void;
@@ -15,8 +16,9 @@ declare class WebSocketServerManager extends EventEmitter {
     triggerEvent(eventType: string, payload: unknown): void;
     reportClientsToFrontend(isDefaultServerStarted: boolean): void;
     getNumberOfOverlayClients(): number;
-    registerCustomWebSocketListener(pluginName: string, handler: CustomWebSocketHandler["handler"]): boolean;
+    registerCustomWebSocketListener(pluginName: string, handler: PluginWebSocketHandler["handler"]): boolean;
     unregisterCustomWebSocketListener(pluginName: string): boolean;
+    registerOverlayRequestHandler<TData extends Record<string, unknown> = Record<string, unknown>, TResponse = unknown>(handler: OverlayRequestWebSocketHandler<TData, TResponse>): boolean;
 }
 declare const manager: WebSocketServerManager;
 export { manager as WebSocketServerManager };

package/shared/compare-versions.d.ts

@@ -0,0 +1,21 @@
+declare enum UpdateType {
+    NONE = "none",
+    PREVIOUS_VERSION = "previousversion",// 1.0.0 -> 1.1.0-beta,
+    PRERELEASE = "prerelease",// 1.0.0 -> 1.1.0-beta
+    OFFICIAL = "official",// 1.0.0-beta -> 1.0.0
+    PATCH = "patch",// 1.0.0 -> 1.0.1
+    MINOR = "minor",// 1.0.0 -> 1.1.0
+    MAJOR = "major",// 1.0.0 -> 2.0.0,
+    MAJOR_PRERELEASE = "majorprerelease"
+}
+interface VersionInfo {
+    major: number;
+    minor?: number;
+    patch?: number;
+    prereleaseTag?: string;
+    prereleaseVersion?: number;
+    nightlyVersion?: string;
+}
+declare function parseVersion(version: string): VersionInfo;
+declare function compareVersions(newVersion: string, currentVersion: string): UpdateType;
+export { UpdateType, parseVersion, compareVersions };

package/types/chat.d.ts

@@ -51,6 +51,7 @@ export type FirebotParsedMessagePart = {
 export type FirebotChatMessage = {
     id: string;
     timestamp?: number;
+    timestampDisplay?: string;
     username: string;
     userId: string;
     userDisplayName?: string;
@@ -83,6 +84,9 @@ export type FirebotChatMessage = {
     isAutoModHeld?: boolean;
     autoModStatus?: "pending" | "approved" | "denied" | "expired";
     autoModReason?: string;
+    autoModHeldMessageId?: string;
+    autoModResolvedBy?: string;
+    autoModErrorMessage?: string;
     isFirstChat?: boolean;
     isReturningChatter?: boolean;
     isRaider?: boolean;
@@ -113,6 +117,12 @@ export type FirebotChatMessage = {
         cost: number;
         imageUrl: string;
     };
+    powerUp?: {
+        id: string;
+        name: string;
+        bits: number;
+        imageUrl: string;
+    };
     isGigantified?: boolean;
 };
 export type FirebotEmote = {
@@ -134,4 +144,70 @@ export type SharedChatParticipant = {
     broadcasterDisplayName: string;
     profilePictureUrl: string;
 };
+type DashboardChatFeedItemType = "message" | "alert" | "reward-redemption" | "power-up-redemption";
+type DashboardChatFeedItemBase = {
+    id: string;
+    type: DashboardChatFeedItemType;
+};
+export type DashboardChatMessageData = FirebotChatMessage & {
+    deleted?: boolean;
+    isHiddenFromChatFeed?: boolean;
+    customHighlightColor?: string;
+    customBannerIcon?: string;
+    customBannerText?: string;
+};
+export type DashboardChatFeedMessageItem = DashboardChatFeedItemBase & {
+    type: "message";
+    data: DashboardChatMessageData;
+    rewardMatched?: boolean;
+    powerUpMatched?: boolean;
+};
+export type DashboardChatFeedAlertItem = DashboardChatFeedItemBase & {
+    type: "alert";
+    message: string;
+    icon: string;
+};
+export type DashboardChatFeedRewardData = {
+    id: string;
+    status: string;
+    messageText: string;
+    user: {
+        id: string;
+        username: string;
+        displayName: string;
+    };
+    reward: {
+        id: string;
+        name: string;
+        cost: number;
+        imageUrl: string;
+    };
+};
+export type DashboardChatFeedRewardItem = DashboardChatFeedItemBase & {
+    type: "reward-redemption";
+    data: DashboardChatFeedRewardData;
+    rewardMatched?: boolean;
+};
+export type DashboardChatFeedPowerUpData = {
+    id: string;
+    status: string;
+    messageText: string;
+    user: {
+        id: string;
+        username: string;
+        displayName: string;
+    };
+    powerUp: {
+        id: string;
+        name: string;
+        bits: number;
+        imageUrl: string;
+    };
+};
+export type DashboardChatFeedPowerUpItem = DashboardChatFeedItemBase & {
+    type: "power-up-redemption";
+    data: DashboardChatFeedPowerUpData;
+    powerUpMatched?: boolean;
+};
+export type DashboardChatFeedItem = DashboardChatFeedMessageItem | DashboardChatFeedAlertItem | DashboardChatFeedRewardItem | DashboardChatFeedPowerUpItem;
 export {};