@crowbartools/firebot-types 5.67.0-alpha25 → 5.67.0-alpha27

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/database/turso-connection-registry.d.ts

@@ -0,0 +1,28 @@
+import { type Database } from "@tursodatabase/database";
+/**
+ *  Registry for Turso databases
+ *
+ * Each named database lives in its own file under the
+ * profile's databases/ dir (ie databases/quotes.db)
+ */
+declare class TursoConnectionRegistry {
+    private logger;
+    private connections;
+    constructor();
+    private getDatabasePath;
+    /**
+     * Returns a cached connection for the named database,
+     * creating the db file if it doesn't exist
+     */
+    getConnection(name: string): Promise<Database>;
+    private open;
+    /**
+     * Attaches another registered database to the given connection so queries
+     * can join across files, ie:
+     * "SELECT ... FROM quotes q JOIN viewers.viewers v ON ..."
+     */
+    attach(db: Database, name: string, alias: string): Promise<void>;
+    private closeAll;
+}
+declare const registry: TursoConnectionRegistry;
+export { registry as TursoConnectionRegistry };

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;
@@ -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/plugins/executors/plugin-executor.interface.d.ts

@@ -10,6 +10,7 @@ export interface PluginRegistrations {
     eventSourceIds?: string[];
     filterIds?: string[];
     systemCommandIds?: string[];
+    conditionIds?: string[];
     restrictionIds?: string[];
     integrationIds?: string[];
     gameIds?: string[];

package/backend/plugins/plugin-api/internal/message-broker.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from "winston";
+import type { ScopedIpc } from "../../../../types/plugin-api";
+export interface MessagingScope {
+    ipc: ScopedIpc;
+    dispose: () => void;
+}
+declare class PluginMessageBroker {
+    private readonly bus;
+    private readonly pendingRequests;
+    constructor();
+    /**
+     * Deep-clone a payload to:
+     * - Isolate senders/receivers from shared mutable references
+     * - Reject non-serializable payloads (ie functions)
+     */
+    private enforceSerialization;
+    createScope(pluginId: string, logger: Logger): MessagingScope;
+}
+export declare const pluginMessageBroker: PluginMessageBroker;
+export {};

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/messaging.d.ts

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

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/quotes/quote-manager.d.ts

@@ -18,7 +18,13 @@ declare class QuoteManager {
     }>;
     constructor();
     private regExpEscape;
+    private buildSearchPattern;
+    private rowToQuote;
     loadQuoteDatabase(): Promise<void>;
+    private createSchema;
+    private migrateFromNeDb;
+    private insertQuoteRow;
+    private getQuoteCount;
     getCurrentQuoteId(): Promise<number>;
     getNextQuoteId(): Promise<number>;
     setQuoteIdIncrementer(number: number): Promise<number>;
@@ -27,13 +33,13 @@ declare class QuoteManager {
     updateQuote(quote: Quote, dontSendUiUpdateEvent?: boolean): Promise<Quote>;
     removeQuote(quoteId: number, dontSendUiUpdateEvent?: boolean): Promise<void>;
     getQuote(quoteId: number): Promise<Quote>;
+    private getRandomQuoteWhere;
     getRandomQuoteByDate(dateConfig: DateConfig): Promise<Quote>;
     getRandomQuoteByAuthor(author: string): Promise<Quote>;
     getRandomQuoteByGame(gameSearch: string): Promise<Quote>;
     getRandomQuoteContainingText(text: string): Promise<Quote>;
     getRandomQuote(): Promise<Quote>;
     getAllQuotes(): Promise<Quote[]>;
-    private updateQuoteId;
     recalculateQuoteIds(): Promise<void>;
     exportQuotesToFile(filepath: string): Promise<boolean>;
 }

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/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-alpha25",
+  "version": "5.67.0-alpha27",
   "description": "Type definitions and plugin API for Firebot plugins.",
   "main": "index.js",
   "types": "index.d.ts",

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 {};

package/types/conditions.d.ts

@@ -0,0 +1,36 @@
+import type EventEmitter from "events";
+import { Trigger, TriggersObject, TriggerType } from "./triggers";
+type PresetValue = {
+    value: string;
+    display: string;
+};
+type ConditionValueType = "text" | "number" | "preset" | "none";
+export type ConditionSettings<ComparisonTypes extends string, LeftSideValueType extends ConditionValueType, RightSideValueType extends ConditionValueType> = {
+    type: string;
+    comparisonType: ComparisonTypes;
+    leftSideValue: LeftSideValueType extends "number" ? number : LeftSideValueType extends "none" ? undefined : string;
+    rightSideValue: RightSideValueType extends "number" ? number : string;
+};
+export type ConditionType<ComparisonTypes extends string, LeftSideValueType extends ConditionValueType, RightSideValueType extends ConditionValueType> = {
+    id: string;
+    name: string;
+    description: string;
+    comparisonTypes: ComparisonTypes[];
+    rightSideValueType: RightSideValueType;
+    leftSideValueType?: LeftSideValueType;
+    triggers?: TriggerType[] | TriggersObject;
+    leftSideTextPlaceholder?: string;
+    rightSideTextPlaceholder?: string;
+    getRightSidePresetValues?: (...args: unknown[]) => PresetValue[];
+    getLeftSidePresetValues?: (...args: unknown[]) => PresetValue[];
+    getRightSideValueDisplay?(condition: ConditionSettings<ComparisonTypes, LeftSideValueType, RightSideValueType>, ...args: unknown[]): string;
+    getLeftSideValueDisplay?(condition: ConditionSettings<ComparisonTypes, LeftSideValueType, RightSideValueType>, ...args: unknown[]): string;
+    valueIsStillValid?(condition: ConditionSettings<ComparisonTypes, LeftSideValueType, RightSideValueType>, ...args: unknown[]): boolean;
+    predicate(conditionSettings: ConditionSettings<ComparisonTypes, LeftSideValueType, RightSideValueType>, trigger: Trigger): boolean | Promise<boolean>;
+};
+export type ConditionManager = EventEmitter & {
+    registerConditionType(conditionType: ConditionType<any, any, any>): void;
+    getConditionTypeById(conditionTypeId: string): ConditionType<any, any, any>;
+    getAllConditionTypes(): ConditionType<any, any, any>[];
+};
+export {};

package/types/index.d.ts

@@ -3,6 +3,7 @@ export * from "./auth";
 export * from "./channel-rewards";
 export * from "./chat";
 export * from "./commands";
+export * from "./conditions";
 export * from "./control-deck";
 export * from "./counters";
 export * from "./currency";

package/types/integrations.d.ts

@@ -43,7 +43,7 @@ export interface IntegrationEvents {
     disconnected: (id: string) => void;
     "settings-update": (id: string, settings: Record<string, any>) => void;
 }
-type LinkData = {
+export type LinkData = {
     accountId: string;
 } | {
     auth: Record<string, unknown>;
@@ -66,4 +66,3 @@ export type IntegrationWithUnknowns = {
     definition: IntegrationDefinition & ObjectOfUnknowns;
     integration: IntegrationController & ObjectOfUnknowns;
 };
-export {};

package/types/plugin-api.d.ts

@@ -8,6 +8,8 @@ import type { InstalledPlugin } from "./plugins";
 import type { PluginWebhook } from "./webhooks";
 import type { ReplaceVariable, VariableConfig } from "./variables";
 import type { FilterConfig, PresetFilterConfig, TextFilterConfig } from "../backend/events/filters/filter-factory";
+import type { FirebotViewer } from "./viewers";
+import type { Currency } from "./currency";
 export type PluginLogMethod = (message: string, ...meta: unknown[]) => void;
 export interface PluginLoggerApi {
     debug: PluginLogMethod;
@@ -106,6 +108,37 @@ export interface PluginFrontendCommunicatorApi {
      */
     fireEventAsync<ReturnPayload = void, ExpectedArg = unknown>(eventName: string, data?: ExpectedArg): Promise<ReturnPayload>;
 }
+export interface PluginMessageEvent<TPayload = unknown> {
+    /** The pluginId of the plugin that sent the message. */
+    sender: string;
+    /** The provided payload. */
+    payload: TPayload;
+}
+/**
+ * Plugin-to-plugin messaging. Supports both fire-and-forget (`emit`/`on`/`off`)
+ * and request/response (`invoke`/`handle`) messaging over a shared event bus,
+ * based on Electron's IPC
+ */
+export interface ScopedIpc {
+    /** Broadcast a message on a channel. */
+    emit(channel: string, data: unknown): void;
+    /**
+     * Listen for messages on a channel.
+     * Returns an `unsubscribe` function.
+     */
+    on<TPayload = unknown>(channel: string, callback: (event: PluginMessageEvent<TPayload>) => void): () => void;
+    /** Remove a previously registered `on` listener. */
+    off(channel: string, callback: (...args: never[]) => void): void;
+    /**
+     * Send a request on a channel and await a response. Rejects if
+     * no handler responds within a 10s timeout or if the handler throws.
+     */
+    invoke<TRequestPayload = unknown, TResponseData = unknown>(channel: string, data?: TRequestPayload): Promise<TResponseData>;
+    /**
+     * Register the handler for a request channel.
+     */
+    handle<TRequestPayload = unknown, TResponseData = unknown>(channel: string, handlerFn: (payload: TRequestPayload, sender: string) => Promise<TResponseData> | TResponseData): void;
+}
 export interface PluginSettingsApi {
     /**
      * Get a Firebot setting value or its default
@@ -127,12 +160,89 @@ export interface Accounts {
 }
 export interface PluginWebServerApi {
     /**
-     * Sends a custom event over the internal Firebot WebSocket server
+     * Send a custom event over the internal Firebot WebSocket server
      * @param name Name of the event to send. Full event name will be `custom-event:{name}`
      * @param data Any optional data you would like to send with the event
      */
     sendWebSocketEvent(name: string, data?: unknown): any;
 }
+export interface PluginViewersApi {
+    /**
+     * Retrieve a Firebot user from the viewer database via their Twitch user ID.
+     * Returns `undefined` if the viewer isn't in the database, or the viewer database is disabled.
+     * @param userId The viewer's Twitch user ID
+     */
+    getViewerByUserId(userId: string): Promise<FirebotViewer>;
+    /**
+     * Retrieve a Firebot user from the viewer database via their Twitch username.
+     * Returns `undefined` if the viewer isn't in the database, or the viewer database is disabled.
+     * @param username The viewer's Twitch username
+     */
+    getViewerByUsername(username: string): Promise<FirebotViewer>;
+    /**
+     * Get a metadata value for a given user
+     * @param userId The viewer's Twitch user ID
+     * @param key Key of the metadata value to get
+     * @param propertyPath (Optional) Dot-notated property path
+     */
+    getViewerMetadataValue(userId: string, key: string, propertyPath: string): Promise<unknown>;
+    /**
+     * Set a metadata value for a given user
+     * @param userId The viewer's Twitch user ID
+     * @param key Key of the metadata value to set
+     * @param value Data to store
+     * @param propertyPath (Optional) Dot-notated property path
+     */
+    setViewerMetadataValue(userId: string, key: string, value: string, propertyPath: string): Promise<void>;
+    /**
+     * Delete a metadata value for a given user
+     * @param userId The viewer's Twitch user ID
+     * @param key Key of the metadata value to delete
+     */
+    deleteViewerMetadataValue(userId: string, key: string): Promise<void>;
+}
+export interface PluginCurrencyApi {
+    /**
+     * Get an array of all currencies
+     */
+    getAllCurrencies(): Array<Currency>;
+    /**
+     * Get a specific currency by its ID
+     * @param id ID of the currency
+     */
+    getCurrencyById(id: string): Currency;
+    /**
+     * Get a specific currency by its name
+     * @param name Name of the currency
+     */
+    getCurrencyByName(name: string): Currency;
+    /**
+     * Get the amount of a viewer's currency
+     * @param userId The viewer's Twitch user ID
+     * @param currencyId The ID of the currency
+     */
+    getViewerCurrency(userId: string, currencyId: string): Promise<number>;
+    /**
+     * Add to or subtract from a viewer's currency
+     * @param userId The viewer's Twitch user ID
+     * @param currencyId The ID of the currency
+     * @param amount An amount to add to the specified currency for the viewer. Negative values will subtract that amount.
+     */
+    addOrSubtractViewerCurrency(userId: string, currencyId: string, amount: number): Promise<boolean>;
+    /**
+     * Set a viewer's currency to a specific amount
+     * @param userId The viewer's Twitch user ID
+     * @param currencyId The ID of the currency
+     * @param amount The total amount of the specified currency the viewer should have
+     */
+    setViewerCurrency(userId: string, currencyId: string, amount: number): Promise<boolean>;
+    /**
+     * Get an array of viewers with a specific currency, sorted by highest amount first
+     * @param currencyId The ID of the currency
+     * @param count The total number of viewers to retrieve
+     */
+    getCurrencyLeaderboard(currencyId: string, count: number): Promise<Array<FirebotViewer>>;
+}
 export interface PluginVariableFactoryApi {
     createEventDataVariable(config: VariableConfig): ReplaceVariable;
 }
@@ -159,12 +269,18 @@ export interface FirebotPluginApi {
     events: PluginEventsApi;
     /** Run effect lists. */
     effects: PluginEffectsApi;
+    /** Access to the viewer database, including viewer metadata */
+    viewers: PluginViewersApi;
+    /** Access to currencies, including viewer currency amounts and leaderboards */
+    currency: PluginCurrencyApi;
     /** Access to Firebot's Twitch API wrappers (Helix, chat, auth, etc). */
     twitch: PluginTwitchApi;
     /** This plugin's saved parameter values. */
     parameters: PluginParametersApi;
     /** Two-way messaging between the plugin and the frontend. */
     frontendCommunicator: PluginFrontendCommunicatorApi;
+    /** Plugin-to-plugin messaging */
+    messaging: ScopedIpc;
     /** Notifications owned by this plugin. */
     notifications: PluginNotificationsApi;
     /** Access to installed plugins. */

package/types/plugins.d.ts

@@ -13,8 +13,29 @@ import type { OverlayWidgetType } from "./overlay-widgets";
 import type { PluginHttpRouteDefinition } from "./http-server";
 import type { CustomWebSocketHandler } from "./websocket";
 import type { PluginWebhooks } from "./webhooks";
+import { ConditionType } from "./conditions";
 type NoResult = Awaitable<void>;
 type GenericParameters = Record<string, unknown>;
+type FontAwesomeIcon = {
+    type: "font-awesome";
+    /**
+     * A FontAwesome icon name shown in the UI (eg. "fa-cogs").
+     */
+    name: `fa-${string}`;
+    /**
+     * A css color value (eg. "#FF0000") used for the icon.
+     */
+    color?: string;
+};
+type CustomIcon = {
+    type: "custom";
+    url: string;
+    /**
+     * A css color value (eg. "#FF0000") used for the background of the icon.
+     */
+    backgroundColor?: string;
+};
+export type PluginIcon = FontAwesomeIcon | CustomIcon;
 export type ManagedPluginManifest = {
     name: string;
     author: string;
@@ -34,16 +55,20 @@ export type ManagedPluginManifest = {
     minimumFirebotVersion?: ManifestFirebotVersion;
     maximumFirebotVersion?: ManifestFirebotVersion;
 };
-export type ManagedPlugin = {
+export type ManagedPluginBase = {
     author: string;
     name: string;
     version: string;
 };
-export type ManagedPluginWithManifest = ManagedPlugin & {
+export type ManagedPlugin = ManagedPluginBase & {
     manifest: ManagedPluginManifest;
 };
+export type ManagedPluginExtended = ManagedPlugin & {
+    installed: boolean;
+    installedVersion?: string;
+};
 export type ManagedPluginUpdateRequest = {
-    plugins: Array<ManagedPlugin>;
+    plugins: Array<ManagedPluginBase>;
     firebotVersion: ManifestFirebotVersion;
 };
 export type InstalledPluginConfig<Params extends GenericParameters = GenericParameters> = {
@@ -51,7 +76,7 @@ export type InstalledPluginConfig<Params extends GenericParameters = GenericPara
     fileName: string;
     enabled?: boolean;
     legacyImport?: boolean;
-    managedPluginDetails?: ManagedPlugin;
+    managedPluginDetails?: ManagedPluginBase;
     parameters: Params;
 };
 export type PluginContext<Params extends FirebotParams = FirebotParams> = {
@@ -70,26 +95,6 @@ export interface ManifestFirebotVersion {
     minor?: number;
     patch?: number;
 }
-type FontAwesomeIcon = {
-    type: "font-awesome";
-    /**
-     * A FontAwesome icon name shown in the UI (eg. "fa-cogs").
-     */
-    name: `fa-${string}`;
-    /**
-     * A css color value (eg. "#FF0000") used for the icon.
-     */
-    color?: string;
-};
-type CustomIcon = {
-    type: "custom";
-    url: string;
-    /**
-     * A css color value (eg. "#FF0000") used for the background of the icon.
-     */
-    backgroundColor?: string;
-};
-export type PluginIcon = FontAwesomeIcon | CustomIcon;
 export interface Manifest {
     name: string;
     version: string;
@@ -119,11 +124,6 @@ export interface Manifest {
      * The icon to be displayed for the plugin.
      */
     icon?: PluginIcon;
-    /**
-     * If true, the plugin will be initialized before parameters are shown to the user,
-     * allowing the plugin to provide custom parameter types that can be used in its own parametersSchema.
-     */
-    initBeforeShowingParams?: boolean;
 }
 export interface PluginBase<Params extends FirebotParams = FirebotParams> {
     manifest: Manifest;
@@ -144,6 +144,7 @@ export interface Plugin<Params extends FirebotParams = FirebotParams> extends Pl
         integrations?: DynamicArray<Integration<any>>;
         filters?: DynamicArray<EventFilter>;
         restrictions?: DynamicArray<RestrictionType<any>>;
+        conditions?: DynamicArray<ConditionType<any, any, any>>;
         systemCommands?: DynamicArray<SystemCommand<any>>;
         games?: DynamicArray<FirebotGame>;
         frontendListeners?: DynamicArray<FrontendListener>;
@@ -211,7 +212,6 @@ type LegacyCustomScriptManifest = {
     author: string;
     website?: string;
     startupOnly?: boolean;
-    initBeforeShowingParams?: boolean;
     firebotVersion?: "5";
 };
 export type LegacyScriptData = {

package/types/ui/modal-factory.d.ts

@@ -19,4 +19,13 @@ export type ModalFactory = {
         trigger?: TriggerType;
         triggerMeta?: unknown;
     }, callback: (result: T) => void, dismissCallback?: () => void) => void;
+    showConfirmationModal: (options: {
+        title: string;
+        question: string;
+        tip?: string;
+        cancelLabel?: string;
+        cancelBtnType?: string;
+        confirmLabel?: string;
+        confirmBtnType?: string;
+    }) => Promise<boolean>;
 };

package/types/ui-extensions.d.ts

@@ -13,7 +13,9 @@ export type AngularJsPage = BasePage & {
 };
 export type IframePage = BasePage & {
     type: 'iframe';
+    url: string;
 };
+export type UiExtensionPage = AngularJsPage | IframePage;
 export type AngularJsFactory = {
     name: string;
     function: Function;
@@ -80,7 +82,7 @@ export type UIExtension = {
     /**
      * Adds new sidebar entries under an "Extensions" category
      */
-    pages?: AngularJsPage[];
+    pages?: UiExtensionPage[];
     /**
      * Add your own AngularJS services, components, directives, filters
      */

package/types/viewers.d.ts

@@ -26,3 +26,12 @@ export interface BasicViewer {
     profilePicUrl?: string;
 }
 export type NewFirebotViewer = BasicViewer & Partial<Omit<FirebotViewer, "_id" | "username" | "displayName" | "twitchRoles" | "profilePicUrl">>;
+export type FrontendViewer = {
+    id: string;
+    username: string;
+    displayName: string;
+    roles: string[];
+    profilePicUrl: string;
+    active: boolean;
+    disableViewerList?: boolean;
+};

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

@@ -1,14 +0,0 @@
-import type { FirebotChatMessage } from "../../types";
-declare class FirebotFrontendChatHelpers {
-    private logger;
-    private _pendingMessageCache;
-    private sendChatMessageToChatWidget;
-    sendChatMessageToFrontend(chatMessage: FirebotChatMessage): void;
-    private deleteMessageFromChatWidget;
-    deleteMessageFromFrontend(messageId: string, animate?: boolean): void;
-    deleteUserMessagesFromFrontend(username: string): void;
-    clearChatFeed(moderatorName: string): void;
-    updateMessageAutomodStatus(messageId: string, newStatus: FirebotChatMessage["autoModStatus"], resolverName: string, resolverId: string, flaggedPhrases: string[]): void;
-}
-declare const frontendChatHelpers: FirebotFrontendChatHelpers;
-export { frontendChatHelpers as FirebotFrontendChatHelpers };