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

package/backend/integrations/builtin/obs/variables/vendor-event-type.d.ts

@@ -0,0 +1,2 @@
+import { ReplaceVariable } from "../../../../../types/variables";
+export declare const VendorEventTypeVariable: ReplaceVariable;

package/backend/integrations/builtin/obs/variables/vendor-name.d.ts

@@ -0,0 +1,2 @@
+import { ReplaceVariable } from "../../../../../types/variables";
+export declare const VendorNameVariable: ReplaceVariable;

package/backend/integrations/builtin/philips-hue/effects/control-light.d.ts

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

package/backend/integrations/builtin/streamloots/filters/card-name.d.ts

@@ -0,0 +1,2 @@
+declare const filter: Omit<import("../../../../../types").EventFilter, "presetValues">;
+export = filter;

package/backend/integrations/builtin/streamloots/filters/card-rarity.d.ts

@@ -0,0 +1,2 @@
+declare const filter: import("../../../../../types").EventFilter;
+export = filter;

package/backend/integrations/builtin/streamloots/filters/chest-gift.d.ts

@@ -0,0 +1,3 @@
+import { EventFilter } from "../../../../../types/events";
+declare const filter: EventFilter;
+export = filter;

package/backend/integrations/builtin/streamloots/filters/chest-quantity.d.ts

@@ -0,0 +1,4 @@
+declare const filter: Omit<import("../../../../../types").EventFilter, "valueType" | "presetValues"> & {
+    valueType: "number";
+};
+export = filter;

package/backend/logwrapper.d.ts

@@ -0,0 +1,3 @@
+import "winston-daily-rotate-file";
+declare const logger: import("winston").Logger;
+export = logger;

package/backend/notifications/notification-manager.d.ts

@@ -0,0 +1,47 @@
+export declare enum NotificationSource {
+    EXTERNAL = "external",
+    INTERNAL = "internal",
+    SCRIPT = "script"
+}
+export declare enum NotificationType {
+    INFO = "info",
+    TIP = "tip",
+    UPDATE = "update",
+    ALERT = "alert"
+}
+export type NotificationBase = {
+    title: string;
+    message: string;
+    type: NotificationType;
+    source?: NotificationSource;
+    scriptName?: string;
+    externalId?: string;
+    metadata?: Record<string, unknown>;
+};
+export type Notification = NotificationBase & {
+    id: string;
+    timestamp: Date;
+    saved: boolean;
+    read: boolean;
+};
+declare class NotificationManager {
+    private _externalCheckInterval;
+    private _notificationCache;
+    constructor();
+    private getNotificationDb;
+    private checkNotificationDbVersion;
+    loadNotificationCache(): void;
+    addNotification(notification: NotificationBase, permanentlySave?: boolean): Notification;
+    private saveNotifications;
+    getNotifications(): Notification[];
+    deleteNotification(id: string): void;
+    markNotificationAsRead(id: string): void;
+    getNotification(id: string): Notification | null;
+    private getKnownExternalNotifications;
+    private setKnownExternalNotifications;
+    private loadExternalNotifications;
+    startExternalNotificationCheck(): void;
+    stopExternalNotificationCheck(): void;
+}
+declare const manager: NotificationManager;
+export { manager as NotificationManager };

package/backend/overlay-widgets/builtin-types/chat/chat-advanced.d.ts

@@ -0,0 +1,25 @@
+import type { OverlayWidgetType, Animation } from "../../../../types";
+import type { ChatWidgetState } from "./chat";
+export type AdvancedChatWidgetSettings = {
+    cssTemplate: string;
+    defaultMessageHtmlTemplate: string;
+    useSeparateTemplateForActions: boolean;
+    actionHtmlTemplate?: string;
+    useSeparateTemplateForHighlightedMessages: boolean;
+    highlightedMessageHtmlTemplate?: string;
+    showSharedChatMessages: boolean;
+    useSeparateTemplateForSharedMessages?: boolean;
+    sharedChatMessageHtmlTemplate?: string;
+    showAnnouncements: boolean;
+    useSeparateTemplateForAnnouncements?: boolean;
+    announcementHtmlTemplate?: string;
+    delayMessages: boolean;
+    messageDelay?: number;
+    newMessageEntryAnimation: Animation;
+    autoRemoveMessages: boolean;
+    messageTimeout?: number;
+    messageExitAnimation?: Animation;
+    thirdPartyEmotes: string[];
+    hiddenUsers: string[];
+};
+export declare const chatAdvanced: OverlayWidgetType<AdvancedChatWidgetSettings, ChatWidgetState>;

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

@@ -0,0 +1,42 @@
+import type { FirebotChatMessage, OverlayWidgetType, FontOptions, Animation } from "../../../../types";
+export type ChatWidgetSettings = {
+    showTimestamps: boolean;
+    showAvatars: boolean;
+    showBadges: boolean;
+    showPronouns: boolean;
+    showSharedChatMessages: boolean;
+    sharedChatInfoStyle?: "none" | "avatar" | "banner";
+    showAnnouncements: boolean;
+    delayMessages: boolean;
+    messageDelay?: number;
+    newMessageEntryAnimation: Animation;
+    autoRemoveMessages: boolean;
+    messageTimeout?: number;
+    messageExitAnimation?: Animation;
+    messageStyle: "compact" | "modern";
+    chatOrder: "normal" | "reversed";
+    actionDisplayFormat: "modern" | "classic";
+    highlightStyle: "normal" | "highlighted";
+    highlightColor?: string;
+    thirdPartyEmotes: string[];
+    hiddenUsers: string[];
+    horizontalAlignment: "left" | "right";
+    verticalAlignment: "top" | "bottom";
+    spaceBetweenMessages: number;
+    usernameFontOptions: FontOptions;
+    messageFontOptions: FontOptions;
+};
+export type ChatWidgetState = {
+    chatMessages: Array<FirebotChatMessage>;
+};
+export type ChatMessageMessageData = {
+    chatMessage: FirebotChatMessage;
+};
+export type DeleteMessageMessageData = {
+    messageId: string;
+    animate: boolean;
+};
+export type DeleteUserMessagesMessageData = {
+    username: string;
+};
+export declare const chat: OverlayWidgetType<ChatWidgetSettings, ChatWidgetState>;

package/backend/overlay-widgets/builtin-types/countdown/countdown-dynamic.d.ts

@@ -0,0 +1,17 @@
+import { FontOptions } from "../../../../types/parameters";
+import { OverlayWidgetType, OverlayWidgetConfig } from "../../../../types/overlay-widgets";
+import type { EffectList } from "../../../../types/effects";
+export type Settings = {
+    fontOptions: FontOptions;
+    alignment: "left" | "center" | "right";
+    runWhenInactive?: boolean;
+    onCompleteEffects?: EffectList;
+};
+export type State = {
+    remainingSeconds: number;
+    mode: "running" | "paused";
+};
+export type DynamicCountdownWidgetConfig = OverlayWidgetConfig<Settings, State> & {
+    type: "firebot:countdown-dynamic";
+};
+export declare const dynamicCountdown: OverlayWidgetType<Settings, State>;

package/backend/overlay-widgets/builtin-types/countdown/countdown-manager.d.ts

@@ -0,0 +1,9 @@
+declare class CountdownManager {
+    private intervalId;
+    startTimer(): void;
+    private doTick;
+    updateCountdownTime(countdownConfigId: string, action: "add" | "subtract" | "set", value: number, onlyIfRunning?: boolean, startIfPaused?: boolean): void;
+    private triggerCompleteEffects;
+}
+declare const countdownManager: CountdownManager;
+export = countdownManager;

package/backend/overlay-widgets/builtin-types/countdown-to-date/countdown-to-date.d.ts

@@ -0,0 +1,12 @@
+import { FontOptions, EffectList, OverlayWidgetType } from "../../../../types";
+type Settings = {
+    targetDateTime: string;
+    format: "simple" | "human";
+    fontOptions?: FontOptions;
+    horizontalAlignment: "left" | "center" | "right";
+    verticalAlignment: "top" | "center" | "bottom";
+    onCompleteEffects?: EffectList;
+};
+type State = Record<never, never>;
+export declare const countdownToDate: OverlayWidgetType<Settings, State>;
+export {};

package/backend/overlay-widgets/builtin-types/counter-display/counter-display.d.ts

@@ -0,0 +1,3 @@
+import type { OverlayWidgetType } from "../../../../types/overlay-widgets";
+import type { Settings, State } from "./counter-display-types";
+export declare const counterDisplay: OverlayWidgetType<Settings, State>;

package/backend/overlay-widgets/builtin-types/current-date-time/current-date-time.d.ts

@@ -0,0 +1,11 @@
+import { OverlayWidgetType } from "../../../../types/overlay-widgets";
+import { FontOptions } from "../../../../types/parameters";
+type Settings = {
+    format?: string;
+    fontOptions?: FontOptions;
+    horizontalAlignment: "left" | "center" | "right";
+    verticalAlignment: "top" | "center" | "bottom";
+};
+type State = {};
+export declare const currentDateTime: OverlayWidgetType<Settings, State>;
+export {};

package/backend/overlay-widgets/builtin-types/custom/custom-advanced.d.ts

@@ -0,0 +1,7 @@
+import { OverlayWidgetType } from "../../../../types/overlay-widgets";
+type Settings = {
+    onEventJs: string;
+};
+type State = {};
+export declare const customAdvanced: OverlayWidgetType<Settings, State>;
+export {};

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

@@ -0,0 +1,10 @@
+import { OverlayWidgetType } from "../../../../types/overlay-widgets";
+type Settings = {
+    html: string;
+    onShowJs?: string;
+    onStateUpdateJs?: string;
+    onMessageJs?: string;
+};
+type State = {};
+export declare const custom: OverlayWidgetType<Settings, State>;
+export {};

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

@@ -0,0 +1,9 @@
+import { OverlayWidgetType } from "../../../../types/overlay-widgets";
+type Settings = {
+    imageType: "local" | "url";
+    filepath: string;
+    url: string;
+};
+type State = {};
+export declare const image: OverlayWidgetType<Settings, State>;
+export {};

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

@@ -0,0 +1,48 @@
+declare const _default: (import("../../../types").OverlayWidgetType<{
+    title?: string;
+    titleFontOptions?: import("../../../types").FontOptions;
+    barColor: string;
+    trackColor: string;
+    orientation: "horizontal" | "vertical";
+    horizontalFillDirection: "left-to-right" | "right-to-left";
+    verticalFillDirection: "bottom-to-top" | "top-to-bottom";
+    endCapStyle: "rounded" | "squared";
+    currentValueDisplay: "hide" | "raw" | "percentage";
+    showMaxValue: boolean;
+    valuePrefix?: string;
+    minValue: number;
+    maxValue: number;
+    onUpdateEffects?: import("../../../types").EffectList;
+    onCompleteEffects?: import("../../../types").EffectList;
+}, {
+    currentValue: number;
+}> | import("../../../types").OverlayWidgetType<import("./countdown/countdown-dynamic").Settings, import("./countdown/countdown-dynamic").State> | import("../../../types").OverlayWidgetType<{
+    html: string;
+    onShowJs?: string;
+    onStateUpdateJs?: string;
+    onMessageJs?: string;
+}, {}> | import("../../../types").OverlayWidgetType<{
+    onEventJs: string;
+}, {}> | import("../../../types").OverlayWidgetType<import("./counter-display/counter-display-types").Settings, import("./counter-display/counter-display-types").State> | import("../../../types").OverlayWidgetType<{
+    text: string;
+    fontOptions?: import("../../../types").FontOptions;
+    horizontalAlignment: "left" | "center" | "right";
+    verticalAlignment: "top" | "center" | "bottom";
+}, {}> | import("../../../types").OverlayWidgetType<{
+    format?: string;
+    fontOptions?: import("../../../types").FontOptions;
+    horizontalAlignment: "left" | "center" | "right";
+    verticalAlignment: "top" | "center" | "bottom";
+}, {}> | import("../../../types").OverlayWidgetType<{
+    targetDateTime: string;
+    format: "simple" | "human";
+    fontOptions?: import("../../../types").FontOptions;
+    horizontalAlignment: "left" | "center" | "right";
+    verticalAlignment: "top" | "center" | "bottom";
+    onCompleteEffects?: import("../../../types").EffectList;
+}, {}> | 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>)[];
+export default _default;

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

@@ -0,0 +1,25 @@
+import { EffectList } from "../../../../types/effects";
+import { OverlayWidgetType } from "../../../../types/overlay-widgets";
+import { FontOptions } from "../../../../types/parameters";
+type Settings = {
+    title?: string;
+    titleFontOptions?: FontOptions;
+    barColor: string;
+    trackColor: string;
+    orientation: "horizontal" | "vertical";
+    horizontalFillDirection: "left-to-right" | "right-to-left";
+    verticalFillDirection: "bottom-to-top" | "top-to-bottom";
+    endCapStyle: "rounded" | "squared";
+    currentValueDisplay: "hide" | "raw" | "percentage";
+    showMaxValue: boolean;
+    valuePrefix?: string;
+    minValue: number;
+    maxValue: number;
+    onUpdateEffects?: EffectList;
+    onCompleteEffects?: EffectList;
+};
+type State = {
+    currentValue: number;
+};
+export declare const progressbar: OverlayWidgetType<Settings, State>;
+export {};

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

@@ -0,0 +1,11 @@
+import { OverlayWidgetType } from "../../../../types/overlay-widgets";
+import { FontOptions } from "../../../../types/parameters";
+type Settings = {
+    text: string;
+    fontOptions?: FontOptions;
+    horizontalAlignment: "left" | "center" | "right";
+    verticalAlignment: "top" | "center" | "bottom";
+};
+type State = {};
+export declare const text: OverlayWidgetType<Settings, State>;
+export {};

package/backend/overlay-widgets/builtin-widget-type-loader.d.ts

@@ -0,0 +1 @@
+export declare function loadWidgetTypes(): void;

package/backend/overlay-widgets/overlay-widget-config-manager.d.ts

@@ -0,0 +1,19 @@
+import { OverlayWidgetConfig } from "../../types/overlay-widgets";
+import JsonDbManager from "../database/json-db-manager";
+type ExtraEvents = {
+    "widget-config-updated": (item: OverlayWidgetConfig, previous: OverlayWidgetConfig) => void;
+    "widget-state-updated": (item: OverlayWidgetConfig, previousState: OverlayWidgetConfig["state"], persisted: boolean) => void;
+    "widget-config-active-changed": (item: OverlayWidgetConfig) => void;
+    "widget-config-removed": (item: OverlayWidgetConfig) => void;
+};
+declare class OverlayWidgetConfigManager extends JsonDbManager<OverlayWidgetConfig, ExtraEvents> {
+    constructor();
+    saveWidgetConfig(config: OverlayWidgetConfig, isNew?: boolean): OverlayWidgetConfig;
+    removeWidgetConfigById(id: string): boolean;
+    getConfigsOfType<Config extends OverlayWidgetConfig = OverlayWidgetConfig>(typeId: string): Config[];
+    getWidgetStateById<State = Record<string, unknown>>(id: string): State | null;
+    setWidgetStateById<State extends Record<string, unknown> = Record<string, unknown>>(id: string, state: State, persist?: boolean): void;
+    triggerUiRefresh(): void;
+}
+declare const manager: OverlayWidgetConfigManager;
+export = manager;

package/backend/overlay-widgets/overlay-widgets-manager.d.ts

@@ -0,0 +1,34 @@
+import { OverlayWidgetConfig, OverlayWidgetType, WidgetUIAction, WidgetOverlayEvent } from "../../types/overlay-widgets";
+import { TypedEmitter } from "tiny-typed-emitter";
+type Events = {
+    "overlay-widget-type-registered": (overlayWidgetType: OverlayWidgetType) => void;
+};
+declare class OverlayWidgetsManager extends TypedEmitter<Events> {
+    private overlayWidgetTypes;
+    constructor();
+    registerOverlayWidgetType(overlayWidgetType: OverlayWidgetType<any, any>): void;
+    getOverlayWidgetType(id: string): OverlayWidgetType | null;
+    getOverlayWidgetTypesForFrontend(): (Pick<OverlayWidgetType, "id" | "name" | "description" | "icon" | "settingsSchema" | "userCanConfigure" | "supportsLivePreview" | "initialState" | "initialAspectRatio" | "nonEditableSettings"> & {
+        uiActions?: Omit<WidgetUIAction, "click">[];
+    })[];
+    getOverlayExtensions(): {
+        typeId: string;
+        dependencies: {
+            css?: string[];
+            js?: Array<string | {
+                module: boolean;
+                url: string;
+            }>;
+            globalStyles?: string;
+        };
+        eventHandler: (event: WidgetOverlayEvent, utils: import("../../types/overlay-widgets").IOverlayWidgetEventUtils) => void;
+        onInitialLoad: (utils: import("../../types/overlay-widgets").IOverlayWidgetInitUtils) => import("../../types").Awaitable<void>;
+    }[];
+    sendWidgetEventToOverlay<EventName extends WidgetOverlayEvent["name"]>(eventName: EventName, widgetConfig: OverlayWidgetConfig, messageInfo?: EventName extends "message" ? {
+        messageName: string;
+        messageData?: unknown;
+    } : undefined, previewMode?: boolean): Promise<void>;
+    private formatForFrontend;
+}
+declare const manager: OverlayWidgetsManager;
+export = manager;

package/backend/power-ups/power-ups-manager.d.ts

@@ -0,0 +1,16 @@
+import { JsonDB } from "node-json-db";
+import { PowerUpRedemptionMetadata, SavedPowerUp } from "../../types/power-ups";
+declare class PowerUpsManager {
+    powerUps: Record<string, SavedPowerUp>;
+    constructor();
+    getPowerUpsDb(): JsonDB;
+    loadPowerUps(): Promise<void>;
+    savePowerUp(powerUp: SavedPowerUp, emitUpdateEvent?: boolean): Promise<SavedPowerUp>;
+    saveAllPowerUps(allPowerUps: SavedPowerUp[]): Promise<void>;
+    getPowerUp(powerUpId: string): SavedPowerUp;
+    getPowerUpIdByName(powerUpName: string): string;
+    private triggerPowerUpEffects;
+    triggerPowerUp(powerUpId: string, metadata: PowerUpRedemptionMetadata, manual?: boolean): Promise<boolean | void>;
+}
+declare const powerUpsManager: PowerUpsManager;
+export = powerUpsManager;

package/backend/pronouns/pronoun-manager.d.ts

@@ -0,0 +1,15 @@
+import { UserPronoun } from "../../types";
+declare class FirebotPronounManager {
+    private _appVersion;
+    private _pronounCache;
+    private _userPronounCache;
+    private _userNoPronounCache;
+    constructor();
+    private callUrl;
+    cachePronouns(): Promise<void>;
+    getUserPronouns(username: string, fallback?: string): Promise<UserPronoun | undefined>;
+    getUserFriendlyPronounString(username: string, fallback?: string, type?: "subject" | "object" | "both"): Promise<string>;
+    getFriendlyPronounString(primary: string, secondary: string | undefined, type?: "subject" | "object" | "both"): string | undefined;
+}
+declare const pronounManager: FirebotPronounManager;
+export { pronounManager as FirebotPronounManager };

package/backend/quick-actions/builtin/give-currency.d.ts

@@ -0,0 +1,3 @@
+import { SystemQuickAction } from "../../../types/quick-actions";
+declare const GiveCurrencyQuickAction: SystemQuickAction;
+export { GiveCurrencyQuickAction };

package/backend/quick-actions/builtin/open-reward-request-queue.d.ts

@@ -0,0 +1,3 @@
+import { SystemQuickAction } from "../../../types/quick-actions";
+declare const OpenRewardQueueQuickAction: SystemQuickAction;
+export { OpenRewardQueueQuickAction };

package/backend/quick-actions/builtin/stream-info.d.ts

@@ -0,0 +1,3 @@
+import { SystemQuickAction } from "../../../types/quick-actions";
+declare const StreamInfoQuickAction: SystemQuickAction;
+export { StreamInfoQuickAction };

package/backend/quick-actions/builtin/stream-preview.d.ts

@@ -0,0 +1,3 @@
+import { SystemQuickAction } from "../../../types/quick-actions";
+declare const StreamPreviewQuickAction: SystemQuickAction;
+export { StreamPreviewQuickAction };

package/backend/quick-actions/quick-action-manager.d.ts

@@ -0,0 +1,16 @@
+import { QuickActionDefinition, SystemQuickAction } from "../../types/quick-actions";
+import JsonDbManager from "../database/json-db-manager";
+declare class QuickActionManager extends JsonDbManager<QuickActionDefinition> {
+    systemQuickActions: SystemQuickAction[];
+    constructor();
+    loadItems(): void;
+    getAllItems(): QuickActionDefinition[];
+    rebuildSettings(): void;
+    saveQuickAction(quickAction: QuickActionDefinition, notify?: boolean): QuickActionDefinition;
+    deleteQuickAction(customQuickActionId: string): void;
+    getSystemQuickActionDefinitions(): QuickActionDefinition[];
+    triggerQuickAction(quickActionId: string): void;
+    triggerUiRefresh(): void;
+}
+declare const quickActionManager: QuickActionManager;
+export { quickActionManager as QuickActionManager };

package/backend/quotes/quote-manager.d.ts

@@ -0,0 +1,40 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { Quote } from "../../types/quotes";
+interface QuoteEventData {
+    quote: Partial<Quote>;
+}
+interface DateConfig {
+    day: number;
+    month: number;
+    year: number;
+}
+declare class QuoteManager {
+    private db;
+    events: TypedEmitter<{
+        "created-item": (data: QuoteEventData) => void;
+        "updated-item": (data: QuoteEventData) => void;
+        "deleted-item": (data: QuoteEventData) => void;
+    }>;
+    constructor();
+    private regExpEscape;
+    loadQuoteDatabase(): Promise<void>;
+    getCurrentQuoteId(): Promise<number>;
+    getNextQuoteId(): Promise<number>;
+    setQuoteIdIncrementer(number: number): Promise<number>;
+    addQuote(quote: Quote): Promise<number>;
+    addQuotes(quotes: Quote[]): Promise<void>;
+    updateQuote(quote: Quote, dontSendUiUpdateEvent?: boolean): Promise<Quote>;
+    removeQuote(quoteId: number, dontSendUiUpdateEvent?: boolean): Promise<void>;
+    getQuote(quoteId: number): Promise<Quote>;
+    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>;
+}
+declare const manager: QuoteManager;
+export { manager as QuoteManager };

package/backend/ranks/rank-command-manager.d.ts

@@ -0,0 +1,20 @@
+import type { SystemCommand } from "../../types/commands";
+import type { RankLadder } from "../../types/ranks";
+type RankCommandRefreshRequestAction = "create" | "update" | "delete";
+type RankCommandOptions = {
+    selfRankMessageTemplate: string;
+    otherRankMessageTemplate: string;
+    rankListMessageTemplate: string;
+    promoteRankMessageTemplate: string;
+    demoteRankMessageTemplate: string;
+    setRankMessageTemplate: string;
+    removeRankMessageTemplate: string;
+};
+declare class RankCommandManager {
+    constructor();
+    createRankCommandDefinition(rankLadder: RankLadder): SystemCommand<RankCommandOptions>;
+    refreshRankCommand(action?: RankCommandRefreshRequestAction, rankLadder?: RankLadder): void;
+    createAllRankLadderCommands(): void;
+}
+declare const rankCommandManager: RankCommandManager;
+export = rankCommandManager;

package/backend/ranks/rank-ladder-helper.d.ts

@@ -0,0 +1,24 @@
+import type { RankLadder, Rank } from "../../types/ranks";
+import type { FirebotViewer } from "../../types/viewers";
+export declare class RankLadderHelper {
+    private readonly rankLadder;
+    constructor(rankLadder: RankLadder);
+    get id(): string;
+    get name(): string;
+    get mode(): "manual" | "auto";
+    get trackBy(): "currency" | "view_time" | "metadata";
+    get currencyId(): string;
+    get metadataKey(): string;
+    get announcePromotionsInChat(): boolean;
+    get promotionMessageTemplate(): string;
+    get restrictedToRoleIds(): string[];
+    getRank(rankId: string): Rank | undefined;
+    getRankByName(name: string): Rank | null;
+    isRankHigher(rankId: string, comparedToRankId: string): boolean;
+    getHighestQualifiedRankId(viewer: FirebotViewer): string | null;
+    getNextRankId(currentRankId?: string): string | null;
+    getPreviousRankId(currentRankId: string): string | null;
+    hasRank(rankId: string): boolean;
+    getRankValueDescription(rankId: string): string | null;
+    private getTrackByValue;
+}

package/backend/ranks/rank-manager.d.ts

@@ -0,0 +1,12 @@
+import type { RankLadder, Rank } from "../../types/ranks";
+import JsonDbManager from "../database/json-db-manager";
+import { RankLadderHelper } from "./rank-ladder-helper";
+declare class RankManager extends JsonDbManager<RankLadder> {
+    constructor();
+    getRankFromLadder(ladder: RankLadder, rankId: string): Rank | undefined;
+    getRankLadderHelpers(): RankLadderHelper[];
+    getRankLadderHelper(rankLadderId: string): RankLadderHelper | null;
+    triggerUiRefresh(): void;
+}
+declare const rankManager: RankManager;
+export = rankManager;

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

@@ -0,0 +1,40 @@
+export declare class Event {
+    target: any;
+    type: string;
+    constructor(type: string, target: any);
+}
+export declare class ErrorEvent extends Event {
+    message: string;
+    error: Error;
+    constructor(error: Error, target: any);
+}
+export declare class CloseEvent extends Event {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+    constructor(code: number, reason: string, target: any);
+}
+export interface WebSocketEventMap {
+    close: CloseEvent;
+    error: ErrorEvent;
+    message: MessageEvent;
+    open: Event;
+    ping: Event;
+}
+export interface WebSocketEventListenerMap {
+    close: (event: CloseEvent) => void | {
+        handleEvent: (event: CloseEvent) => void;
+    };
+    error: (event: ErrorEvent) => void | {
+        handleEvent: (event: ErrorEvent) => void;
+    };
+    message: (event: MessageEvent) => void | {
+        handleEvent: (event: MessageEvent) => void;
+    };
+    open: (event: Event) => void | {
+        handleEvent: (event: Event) => void;
+    };
+    ping: (event: Event) => void | {
+        handleEvent: (event: Event) => void;
+    };
+}