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

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

@@ -0,0 +1,99 @@
+import type { InstalledPlugin, InstalledPluginConfig, PluginDetails, PluginType, Trigger } from "../../types";
+import { EffectScriptExecutionResult } from "./executors/plugin-executor.interface";
+type GetPluginDetailsResult = {
+    success: true;
+    fileName: string;
+    pluginType: "plugin" | "script";
+    details: PluginDetails;
+} | {
+    success: false;
+    error: string;
+};
+declare class PluginManager {
+    private startingPlugins;
+    private activePlugins;
+    private pendingApiInstances;
+    private requireInterceptorInstalled;
+    private pluginExecutors;
+    private legacyEffectScriptExecutor;
+    constructor();
+    migrateLegacyStartUpScriptsToPlugins(): Promise<void>;
+    startPlugin(pluginConfig: InstalledPluginConfig, installing?: boolean): Promise<void>;
+    private doStartPlugin;
+    startPlugins(): Promise<void>;
+    stopPlugin(pluginId: string, uninstalling?: boolean): Promise<void>;
+    /**
+     * Convenience helper for hot-reloading. Finds an active plugin by its plugin file
+     * name and restarts it (stop then start). Does nothing if no active plugin matches.
+     */
+    restartPluginByFileName(fileName: string): Promise<void>;
+    stopAllPlugins(): Promise<void>;
+    /**
+     * 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>;
+    setPluginEnabled(pluginId: string, enabled: boolean): Promise<void>;
+    getInstalledPlugins(): Promise<InstalledPlugin[]>;
+    private doGetPluginDetailsByFileName;
+    /**
+     * Loads a plugin file (without persisting a config) and returns its details for
+     * the install / edit UI.
+     */
+    getPluginDetailsByFileName(fileName: string, expectedPluginType?: PluginType): Promise<GetPluginDetailsResult>;
+    /**
+     * 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 | {
+        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.
+     */
+    onPluginConfigDeleted(pluginConfig: InstalledPluginConfig): Promise<void>;
+    deletePluginFileIfUnreferenced(fileName: string): Promise<void>;
+    /**
+     * Remove an installed plugin. Stops the plugin and deletes its config, and
+     * optionally deletes the underlying plugin file from the scripts folder.
+     */
+    deletePlugin(pluginId: string, deletePluginFile?: boolean): Promise<boolean>;
+    /**
+     * Replace the underlying plugin file for an existing plugin config with a new file
+     * chosen on disk.
+     */
+    updatePluginFromPath(pluginId: string, sourcePath: string, overwrite?: boolean): Promise<GetPluginDetailsResult | {
+        success: false;
+        error: string;
+        conflict?: boolean;
+    }>;
+    runEffectScript(effectData: {
+        scriptName: string;
+        parameters?: Record<string, unknown>;
+    }, trigger?: Trigger): Promise<EffectScriptExecutionResult | undefined>;
+    private getPluginFilePath;
+    private getActivePluginByFileName;
+    private findPluginExecutor;
+    private installRequireInterceptor;
+    private createApiInstance;
+    private loadPlugin;
+    /**
+     * Hack to load a plugin without registering it in `require.cache`.
+     *
+     * Used for read-only inspection (manifest / parameter schema lookup) so that
+     * loading a fresh copy of a plugin does not evict or replace the cached module
+     * of a currently-running plugin is holding a reference to.
+     */
+    private loadPluginIsolated;
+    private isValidPlugin;
+}
+declare const pluginManager: PluginManager;
+export { pluginManager as PluginManager };

package/backend/plugins/plugin-manifest-utils.d.ts

@@ -0,0 +1,8 @@
+import { Manifest } from "../../types";
+/**
+ * Resolves the external links (repo / website / support) for a plugin manifest.
+ *
+ * When the manifest `repo` points at a GitHub repository, `website` and `support`
+ *   are auto-populated when not explicitly provided.
+ */
+export declare function resolvePluginManifestLinks<T extends Manifest>(manifest: T): T;

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

@@ -0,0 +1,17 @@
+import { JsonDB } from "node-json-db";
+import type { PowerUpRedemptionMetadata, SavedPowerUp } from "../../types";
+declare class PowerUpsManager {
+    private logger;
+    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,16 @@
+import { UserPronoun } from "../../types";
+declare class FirebotPronounManager {
+    private logger;
+    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 type { SystemQuickAction } from "../../../types";
+declare const GiveCurrencyQuickAction: SystemQuickAction;
+export { GiveCurrencyQuickAction };

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+import { QuickActionDefinition, SystemQuickAction } from "../../types";
+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,41 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { Quote } from "../../types";
+interface QuoteEventData {
+    quote: Partial<Quote>;
+}
+interface DateConfig {
+    day: number;
+    month: number;
+    year: number;
+}
+declare class QuoteManager {
+    private logger;
+    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 { RankLadder, SystemCommand } from "../../types";
+type RankCommandRefreshRequestAction = "create" | "update" | "delete";
+type RankCommandOptions = {
+    selfRankMessageTemplate: string;
+    otherRankMessageTemplate: string;
+    rankListMessageTemplate: string;
+    promoteRankMessageTemplate: string;
+    demoteRankMessageTemplate: string;
+    setRankMessageTemplate: string;
+    removeRankMessageTemplate: string;
+};
+declare class RankCommandManager {
+    private logger;
+    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,23 @@
+import type { FirebotViewer, RankLadder, Rank } from "../../types";
+export declare class RankLadderHelper {
+    private readonly rankLadder;
+    constructor(rankLadder: RankLadder);
+    get id(): string;
+    get name(): string;
+    get mode(): "manual" | "auto";
+    get trackBy(): "view_time" | "currency" | "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";
+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;
+    };
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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