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

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

@@ -0,0 +1,44 @@
+import { AllowList, BannedRegularExpressions, BannedWords, ChatModerationSettings } from "../../../types/moderation";
+import { FirebotChatMessage } from "../../../types/chat";
+declare class ChatModerationManager {
+    bannedWords: BannedWords;
+    bannedRegularExpressions: BannedRegularExpressions;
+    allowlist: AllowList;
+    chatModerationSettings: ChatModerationSettings;
+    constructor();
+    private getBannedWordsDb;
+    private getBannedWordsList;
+    private addBannedWords;
+    private removeBannedWord;
+    private removeAllBannedWords;
+    private importBannedWordList;
+    private saveBannedWordList;
+    private getBannedRegularExpressionsDb;
+    private getBannedRegularExpressionsList;
+    private addBannedRegularExpression;
+    private removeBannedRegularExpression;
+    private removeAllBannedRegularExpressions;
+    private saveBannedRegularExpressionsList;
+    private getAllowlistDb;
+    private getUrlAllowlist;
+    private addAllowedUrls;
+    private removeAllowedUrl;
+    private removeAllAllowedUrls;
+    private importUrlAllowlist;
+    private saveUrlAllowlist;
+    private getUserAllowlist;
+    private addAllowedUser;
+    private removeAllowedUser;
+    private removeAllAllowedUsers;
+    private saveUserAllowlist;
+    private getChatModerationSettingsDb;
+    private saveChatModerationSettings;
+    private countEmojis;
+    private hasBannedWord;
+    private matchesBannedRegex;
+    private deleteMessage;
+    load(): void;
+    moderateMessage(chatMessage: FirebotChatMessage): Promise<void>;
+}
+declare const chatModerationManager: ChatModerationManager;
+export { chatModerationManager as ChatModerationManager };

package/backend/chat/moderation/raid-message-checker.d.ts

@@ -0,0 +1,19 @@
+interface RaidMessage {
+    rawText: string;
+    userId: string;
+}
+declare class RaidMessageChecker {
+    private readonly _chatCacheLimit;
+    private _messageCache;
+    private _raidMessage;
+    private _checkerEnabled;
+    private _settings;
+    private handleRaider;
+    private getRaidMessage;
+    private checkPreviousMessages;
+    sendMessageToCache(raidMessage: RaidMessage): Promise<void>;
+    enable(shouldBan: boolean, shouldBlock: boolean): Promise<void>;
+    disable(): void;
+}
+declare const raidMessageChecker: RaidMessageChecker;
+export = raidMessageChecker;

package/backend/chat/moderation/url-permit-command.d.ts

@@ -0,0 +1,10 @@
+declare class PermitManager {
+    private readonly _permidCommandId;
+    private _tempPermittedUsers;
+    private readonly _permitCommand;
+    hasTemporaryPermission(username: string): boolean;
+    registerPermitCommand(): void;
+    unregisterPermitCommand(): void;
+}
+declare const manager: PermitManager;
+export = manager;

package/backend/chat/third-party/7tv.d.ts

@@ -0,0 +1,29 @@
+import { ThirdPartyEmote, ThirdPartyEmoteProvider } from "./third-party-emote-provider";
+type SevenTVEmotesResponse = {
+    emotes: Array<{
+        name: string;
+        data: {
+            animated: boolean;
+            host: {
+                url: string;
+                files: Array<{
+                    name: string;
+                    static_name: string;
+                }>;
+            };
+        };
+    }>;
+};
+type SevenTVChannelEmotesResponse = {
+    emote_set: SevenTVEmotesResponse;
+};
+export declare class SevenTVEmoteProvider extends ThirdPartyEmoteProvider<SevenTVEmotesResponse, SevenTVChannelEmotesResponse> {
+    providerName: string;
+    globalEmoteUrl: string;
+    getChannelEmotesUrl(streamerUserId: string): string;
+    private globalEmoteMapper;
+    private channelEmoteMapper;
+    globalEmotesMapper: (response: SevenTVEmotesResponse) => ThirdPartyEmote[];
+    channelEmotesMapper: (response: SevenTVChannelEmotesResponse) => ThirdPartyEmote[];
+}
+export {};

package/backend/chat/third-party/bttv.d.ts

@@ -0,0 +1,19 @@
+import { ThirdPartyEmote, ThirdPartyEmoteProvider } from "./third-party-emote-provider";
+type BTTVEmotesResponse = Array<{
+    id: string;
+    code: string;
+    imageType: string;
+}>;
+type BTTVChannelEmotesResponse = {
+    channelEmotes: BTTVEmotesResponse;
+    sharedEmotes: BTTVEmotesResponse;
+};
+export declare class BTTVEmoteProvider extends ThirdPartyEmoteProvider<BTTVEmotesResponse, BTTVChannelEmotesResponse> {
+    providerName: string;
+    globalEmoteUrl: string;
+    getChannelEmotesUrl(streamerUserId: string): string;
+    private emoteMapper;
+    globalEmotesMapper: (response: BTTVEmotesResponse) => ThirdPartyEmote[];
+    channelEmotesMapper(response: BTTVChannelEmotesResponse): ThirdPartyEmote[];
+}
+export {};

package/backend/chat/third-party/ffz.d.ts

@@ -0,0 +1,19 @@
+import { ThirdPartyEmote, ThirdPartyEmoteProvider } from "./third-party-emote-provider";
+type FFZEmotesResponse = Array<{
+    images: {
+        "1x": string;
+        "2x": string;
+        "4x": string;
+    };
+    code: string;
+    imageType: string;
+}>;
+export declare class FFZEmoteProvider extends ThirdPartyEmoteProvider<FFZEmotesResponse> {
+    providerName: string;
+    globalEmoteUrl: string;
+    getChannelEmotesUrl(streamerUserId: string): string;
+    private emoteMapper;
+    globalEmotesMapper: (response: FFZEmotesResponse) => ThirdPartyEmote[];
+    channelEmotesMapper: (response: FFZEmotesResponse) => ThirdPartyEmote[];
+}
+export {};

package/backend/chat/third-party/third-party-emote-provider.d.ts

@@ -0,0 +1,14 @@
+export declare class ThirdPartyEmote {
+    origin: string;
+    url: string;
+    code: string;
+    animated: boolean;
+}
+export declare abstract class ThirdPartyEmoteProvider<GlobalEmotesResponse, ChannelEmotesResponse = GlobalEmotesResponse> {
+    abstract providerName: string;
+    abstract globalEmoteUrl: string;
+    abstract getChannelEmotesUrl(streamerUserId: string): string;
+    abstract globalEmotesMapper(response: GlobalEmotesResponse): ThirdPartyEmote[];
+    abstract channelEmotesMapper(response: ChannelEmotesResponse): ThirdPartyEmote[];
+    getAllEmotes(): Promise<ThirdPartyEmote[]>;
+}

package/backend/chat/twitch-chat.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from "events";
+declare class TwitchChat extends EventEmitter {
+    private _streamerChatClient;
+    private _botChatClient;
+    constructor();
+    /**
+     * Whether or not the streamer is currently connected
+     */
+    get chatIsConnected(): boolean;
+    /**
+     * Disconnects the streamer and bot from chat
+     */
+    disconnect(emitDisconnectEvent?: boolean): void;
+    /**
+     * Connects the streamer and bot to chat
+     */
+    connect(): Promise<void>;
+    private connectBotClient;
+    /**
+     * Sends the message as the bot if available, otherwise as the streamer.
+     * If a username is provided, the message will be whispered.
+     * If the message is too long, it will be automatically broken into multiple fragments and sent individually.
+     *
+     * @param message The message to send
+     * @param username If provided, message will be whispered to the given user.
+     * @param accountType Which account to chat as. Defaults to bot if available otherwise, the streamer.
+     * @param replyToMessageId A message id to reply to
+     * @deprecated Use the API wrapper methods ({@linkcode TwitchApi.chat.sendChatMessage()} and {@linkcode TwitchApi.whispers.sendWhisper()}) instead
+     */
+    sendChatMessage(message: string, username?: string, accountType?: string, replyToMessageId?: string): Promise<void>;
+}
+declare const twitchChat: TwitchChat;
+export = twitchChat;

package/backend/cloud-sync/index.d.ts

@@ -0,0 +1,9 @@
+interface ProfileSyncData {
+    username: string;
+    userRoles: string[];
+    profilePage: "commands" | "quotes";
+}
+export declare function sync<T = unknown>(jsonData: T): Promise<string>;
+export declare function getData<T = unknown>(shareCode: string): Promise<T>;
+export declare function syncProfileData(profileSyncData: ProfileSyncData): Promise<string>;
+export {};

package/backend/cloud-sync/sync-handlers/command-list.d.ts

@@ -0,0 +1,3 @@
+export declare function getCommandListForSync(): {
+    allowedCmds: any[];
+};

package/backend/cloud-sync/sync-handlers/quotes-list.d.ts

@@ -0,0 +1,3 @@
+export declare function getQuoteListForSync(): Promise<{
+    quotes: import("../../../types").Quote[];
+}>;

package/backend/common/account-access.d.ts

@@ -0,0 +1,46 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { FirebotAccount } from "../../types/accounts";
+type AccountType = "streamer" | "bot";
+type AccountCache = {
+    [accountType in AccountType]: FirebotAccount;
+};
+interface AccountAuthUpdateEvent {
+    accountType: AccountType;
+    account: FirebotAccount;
+}
+type Events = {
+    "account-update": (cache: AccountCache) => void;
+    "account-auth-update": (event: AccountAuthUpdateEvent) => void;
+};
+declare class AccountAccess extends TypedEmitter<Events> {
+    private _cache;
+    private _accountTokenIssueFlags;
+    private _readyResolve;
+    readyPromise: Promise<unknown>;
+    constructor();
+    getAccounts(): AccountCache;
+    streamerTokenIssue(): boolean;
+    botTokenIssue(): boolean;
+    private sendAccountUpdate;
+    private sendAccountAuthUpdate;
+    /**
+     * Updates a streamer account object with various settings
+     */
+    updateStreamerAccountSettings(streamerAccount: FirebotAccount): FirebotAccount;
+    private saveAccountDataToFile;
+    /**
+     * Loads account data from file into memory
+     * @param emitUpdate If an account update event should be emitted
+     */
+    loadAccountData(emitUpdate?: boolean): void;
+    /**
+     * Update and save data for an account
+     * @param accountType The type of account
+     * @param account The account
+     */
+    updateAccount(accountType: AccountType, account: FirebotAccount, emitGeneralUpdate?: boolean, emitAuthUpdateEvent?: boolean): void;
+    removeAccount(accountType: AccountType): void;
+    setAccountTokenIssue(accountType: AccountType): void;
+}
+declare const accountAccess: AccountAccess;
+export { accountAccess as AccountAccess };

package/backend/common/argv-parser.d.ts

@@ -0,0 +1,3 @@
+import parser from "yargs-parser";
+declare const argv: parser.Arguments;
+export default argv;

package/backend/common/custom-variable-manager.d.ts

@@ -0,0 +1,45 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import { WrappedValue } from "node-cache";
+interface CustomVariableInspectorItem {
+    key: string;
+    value: unknown;
+    ttl: number;
+}
+type FirebotCacheData = {
+    [key: string]: WrappedValue<unknown> & {
+        meta?: {
+            persist?: boolean;
+        };
+    };
+};
+declare class CustomVariableManager extends TypedEmitter<{
+    "created-item": (item: {
+        name: string;
+        value: unknown;
+    }) => void;
+    "updated-item": (item: {
+        name: string;
+        value: unknown;
+    }) => void;
+    "deleted-item": (item: {
+        name: string;
+        value: unknown;
+    }) => void;
+}> {
+    private _cache;
+    constructor();
+    private onCustomVariableCreate;
+    private onCustomVariableExpire;
+    private onCustomVariableDelete;
+    private getVariableCacheDb;
+    getInitialInspectorVariables(): CustomVariableInspectorItem[];
+    getAllVariables(): FirebotCacheData;
+    persistVariablesToFile(): void;
+    loadVariablesFromFile(): void;
+    private setValueWithMeta;
+    addCustomVariable(name: string, data: unknown, ttl?: number, propertyPath?: string, persist?: boolean): void;
+    getCustomVariable<T = unknown>(name: string, propertyPath?: string, defaultData?: T): T;
+    deleteCustomVariable(name: string): void;
+}
+declare const manager: CustomVariableManager;
+export { manager as CustomVariableManager };

package/backend/common/data-access.d.ts

@@ -0,0 +1,23 @@
+import fs from "fs";
+import { JsonDB } from "node-json-db";
+export declare function getWorkingDirectoryPath(): string;
+declare let tmpDirectoryPath: string;
+export declare function getPathInUserData(filePath: string): string;
+export declare function getPathInWorkingDir(filePath: string): string;
+export declare function getPathInTmpDir(filePath: string): string;
+export declare function deletePathInTmpDir(filePath: string): void;
+export declare function deletePathInUserData(filePath: string): void;
+export declare function deleteFolderRecursive(pathname: string): void;
+export declare function getUserDataPath(): string;
+export declare function createFirebotDataDir(): Promise<void>;
+export declare function getJsonDbInUserData(filePath: string): JsonDB;
+export declare function makeDirInUserData(filePath: string): Promise<void>;
+export declare function makeDirInUserDataSync(filePath: string): boolean;
+export declare function writeFileInWorkingDir(filePath: string, data: string, callback: fs.NoParamCallback): void;
+export declare function writeFileInUserData(filePath: string, data: string, callback: fs.NoParamCallback): void;
+export declare function copyDefaultConfigToUserData(configFileName: string, userDataDestination: string): void;
+export declare function copyResourceToUserData(resourcePath: string, resourceName: string, userDataDestination?: string): void;
+export declare function workingDirPathExists(filePath: string): Promise<unknown>;
+export declare function userDataPathExists(filePath: string): Promise<boolean>;
+export declare function userDataPathExistsSync(filePath: string): boolean;
+export { tmpDirectoryPath as getTmpDirectory };

package/backend/common/debug-info.d.ts

@@ -0,0 +1 @@
+export declare function copyDebugInfoToClipboard(): Promise<void>;

package/backend/common/effect-abort-helpers.d.ts

@@ -0,0 +1,10 @@
+type EffectAbortData = {
+    executionId: string;
+    abortController: AbortController;
+};
+export declare function addEffectAbortController(type: "effect" | "effect-list", effectOrEffectListId: string, abortData: EffectAbortData): void;
+export declare function removeEffectAbortController(type: "effect" | "effect-list", effectOrEffectListId: string, executionId: string): void;
+export declare function abortEffectList(effectListId: string, bubbleStop?: boolean): void;
+export declare function abortEffect(effectId: string): void;
+export declare function abortAllEffectLists(bubbleStop?: boolean): void;
+export {};

package/backend/common/effect-run-mode-handler.d.ts

@@ -0,0 +1,2 @@
+import { EffectInstance, EffectList } from "../../types";
+export declare function resolveEffectsForExecution(effectList: EffectList): EffectInstance[];

package/backend/common/frontend-communicator.d.ts

@@ -0,0 +1,15 @@
+import type { FrontendCommunicatorModule } from "../../types";
+declare class FrontendCommunicator implements FrontendCommunicatorModule {
+    private _listeners;
+    private registerEventWithElectron;
+    send<ExpectedArg = unknown>(eventName: string, data?: ExpectedArg): void;
+    sendToVariableInspector(eventName: string, data?: unknown): void;
+    fireEventAsync<ReturnPayload = void, ExpectedArg = unknown>(eventName: string, data?: ExpectedArg): Promise<ReturnPayload>;
+    private registerListener;
+    on<ExpectedArgs extends Array<unknown> = [], ReturnPayload = void>(eventName: string, callback: (...args: ExpectedArgs) => ReturnPayload): string;
+    onAsync<ExpectedArgs extends Array<unknown> = [], ReturnPayload = void>(eventName: string, callback: (...args: ExpectedArgs) => Promise<ReturnPayload>): string;
+    private unregisterListener;
+    off(eventName: string, id: string): void;
+}
+declare const frontendCommunicator: FrontendCommunicator;
+export = frontendCommunicator;

package/backend/common/handlers/dice-processor.d.ts

@@ -0,0 +1,10 @@
+import { Trigger } from "../../../types/triggers";
+export interface DiceEffectModel {
+    dice: string;
+    chatter: string;
+    whisper: string;
+    resultType: string;
+}
+declare function processDice(diceConfig: string, showEach: boolean): string | number;
+declare function handleDiceEffect(effect: DiceEffectModel, trigger: Trigger): Promise<void>;
+export { handleDiceEffect, processDice };

package/backend/common/handlers/js-sandbox/sandbox-eval.d.ts

@@ -0,0 +1,2 @@
+import type { Trigger } from '../../../../types/triggers';
+export declare const evalSandboxedJs: (code: string, args: unknown[], trigger: Trigger) => Promise<unknown>;

package/backend/common/handlers/reddit-processor.d.ts

@@ -0,0 +1,2 @@
+declare function randomImageFromSubReddit(subreddit: string): Promise<string>;
+export { randomImageFromSubReddit as getRandomImage };

package/backend/common/handlers/sound-handler.d.ts

@@ -0,0 +1,14 @@
+import type { FirebotAudioDevice } from "../../../types";
+export type SoundType = "url" | "rawData" | "folderRandom" | "local";
+export declare function playSound(soundData: {
+    soundType: SoundType;
+    filePath?: string;
+    url?: string;
+    rawData?: Uint8Array | number[] | string;
+    mimeType?: string;
+    folder?: string;
+    volume?: number;
+    overlayInstance?: string;
+    audioOutputDevice?: FirebotAudioDevice;
+    waitForSound?: boolean;
+}): Promise<boolean>;

package/backend/common/handlers/twitch-clip-url-resolver.d.ts

@@ -0,0 +1,5 @@
+import { HelixClip } from '@twurple/api';
+export declare const resolveTwitchClipVideoUrl: (clip: HelixClip) => Promise<{
+    url: string;
+    useIframe: boolean;
+}>;

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

@@ -0,0 +1,8 @@
+import { FontAwesomeIcon } from "../../types/icons";
+declare class IconManager {
+    icons: FontAwesomeIcon[];
+    constructor();
+    loadFontAwesomeIcons(): Promise<void>;
+}
+declare const iconManager: IconManager;
+export { iconManager as IconManager };

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

@@ -0,0 +1,21 @@
+import { JsonDB } from "node-json-db";
+declare class ProfileManager {
+    loggedInUser: string;
+    profileToRename: string;
+    constructor();
+    private restartApp;
+    logInProfile(profileId: string, restart?: boolean): void;
+    createNewProfile(profileId?: string, restart?: boolean): void;
+    getLoggedInProfile(restartIfNotLoggedIn?: boolean): string;
+    renameProfile(newProfileId: string): void;
+    deleteProfile(): void;
+    getPathInProfile(filepath: string): string;
+    private getPathInProfileRelativeToUserData;
+    getJsonDbInProfile(filepath: string, humanReadable?: boolean): JsonDB;
+    profileDataPathExistsSync(filePath: string): boolean;
+    deletePathInProfile(filePath: string): void;
+    getNewProfileName: () => string;
+    hasProfileRename: () => boolean;
+}
+declare const manager: ProfileManager;
+export { manager as ProfileManager };

package/backend/common/screenshot-helpers.d.ts

@@ -0,0 +1,24 @@
+import type { CustomEmbed, EmbedType } from "../../types/discord";
+export declare function saveScreenshotToFolder(base64ImageData: string, folderPath: string, fileName?: string): Promise<void>;
+export declare function saveScreenshotToFile(base64ImageData: string, filePath: string): Promise<void>;
+export declare function sendScreenshotToDiscord(base64ImageData: string, message: string, discordChannelId: string, color: string): Promise<void>;
+export declare function sendEmbedToDiscord(base64ImageData: string, embedType: EmbedType, message: string, embed: CustomEmbed, discordChannelId: string, color: string): Promise<void>;
+export type ScreenshotEffectData = {
+    position: string;
+    overlayInstance: string;
+    width: number;
+    height: number;
+    duration: number;
+    customCoords?: string;
+    enterAnimation?: string;
+    enterDuration?: number;
+    inbetweenAnimation?: string;
+    inbetweenDuration?: number;
+    inbetweenDelay?: number;
+    inbetweenRepeat?: number;
+    exitAnimation?: string;
+    exitDuration?: number;
+    rotation?: string;
+    rotType?: string;
+};
+export declare function sendScreenshotToOverlay(screenshotDataUrl: string, effect: ScreenshotEffectData): void;

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

@@ -0,0 +1,141 @@
+import { EventEmitter } from "events";
+import { FirebotAutoUpdateLevel, FirebotSettingsTypes } from "../../types/settings";
+declare class SettingsManager extends EventEmitter {
+    settingsCache: Partial<Record<keyof FirebotSettingsTypes, unknown>>;
+    constructor();
+    private getLoggedInProfilePath;
+    private getSettingsFile;
+    private getGlobalSettingsFile;
+    private handleCorruptSettingsFile;
+    private migrateUserSettingsToGlobal;
+    private userSettingExists;
+    private globalSettingExists;
+    private getDataFromFile;
+    private getDataFromGlobalSettingsFile;
+    private pushDataToFile;
+    private pushDataToGlobalSettingsFile;
+    private deleteUserDataAtPath;
+    private deleteGlobalDataAtPath;
+    /**
+     * Get the JSON data path for a specific Firebot setting in the settings file
+     *
+     * @param settingName Name of the setting
+     * @returns String representing the full JSON path of the setting data
+     */
+    getSettingPath(settingName: keyof FirebotSettingsTypes): string;
+    /**
+     * Get a Firebot setting value or its default
+     *
+     * @param settingName Name of the setting to get
+     * @param forceCacheUpdate Force an update to the settings cache. Defaults to `false`.
+     * @returns Setting value, or the default if one isn't explicitly set
+     */
+    getSetting<SettingName extends keyof FirebotSettingsTypes>(settingName: SettingName, forceCacheUpdate?: boolean): FirebotSettingsTypes[SettingName];
+    /**
+     * Save a Firebot setting
+     *
+     * @param settingName Name of the setting to save
+     * @param data Setting data
+     */
+    saveSetting<SettingName extends keyof FirebotSettingsTypes>(settingName: SettingName, data: FirebotSettingsTypes[SettingName]): void;
+    /**
+     * Delete a Firebot setting
+     *
+     * @param settingName Name of the setting to delete
+     */
+    deleteSetting<SettingName extends keyof FirebotSettingsTypes>(settingName: SettingName): void;
+    /**
+     * Get a plugin setting or its default
+     *
+     * @param pluginName Name of the plugin
+     * @param settingName Name of the setting
+     * @param forceCacheUpdate Force an update to the settings cache. Defaults to `false`.
+     * @param defaultValue The default value to return if one isn't explicitly defined
+     * @returns The saved plugin setting value, or the default if it doesn't exist.
+     */
+    getPluginSetting(pluginName: string, settingName: string, forceCacheUpdate?: boolean, defaultValue?: unknown): unknown;
+    /**
+     * Flushes the settings cache, forcing all settings to be retrieved from file on the next retrieval
+     */
+    flushSettingsCache(): void;
+    /** @deprecated Use `getSetting("EventSettings")` instead */
+    getEventSettings: () => object;
+    /** @deprecated Use `getSetting("IgnoreSubsequentSubEventsAfterCommunitySub")` instead */
+    ignoreSubsequentSubEventsAfterCommunitySub: () => boolean;
+    /** @deprecated Use `getSetting("JustUpdated")` instead */
+    hasJustUpdated: () => boolean;
+    /** @deprecated Use `saveSetting("JustUpdated", value)` instead */
+    setJustUpdated: (value: boolean) => void;
+    /** @deprecated Use `getSetting("CopiedOverlayVersion")` instead */
+    getOverlayVersion: () => string;
+    /** @deprecated Use `saveSetting("CopiedOverlayVersion", value)` instead */
+    setOverlayVersion: (value: string) => void;
+    /** @deprecated Use `getSetting("ClearCustomScriptCache")` instead */
+    getClearCustomScriptCache: () => boolean;
+    /** @deprecated Use `saveSetting("ClearCustomScriptCache", value)` instead */
+    setClearCustomScriptCache: (value: boolean) => void;
+    /** @deprecated Use `getSetting("RunCustomScripts")` instead */
+    isCustomScriptsEnabled: () => boolean;
+    /** @deprecated Use `getSetting("RunCustomScripts")` instead */
+    getCustomScriptsEnabled: () => boolean;
+    /** @deprecated Use `saveSetting("RunCustomScripts", value)` instead */
+    setCustomScriptsEnabled: (value: boolean) => void;
+    /** @deprecated Use `getSetting("PersistCustomVariables")` instead */
+    getPersistCustomVariables: () => boolean;
+    /** @deprecated Use `saveSetting("PersistCustomVariables", value)` instead */
+    setPersistCustomVariables: (value: boolean) => void;
+    /** @deprecated Use `getSetting("UseOverlayInstances")` instead */
+    useOverlayInstances: () => boolean;
+    /** @deprecated Use `saveSetting("UseOverlayInstances", value)` instead */
+    setUseOverlayInstances: (value: boolean) => void;
+    /** @deprecated Use `getSetting("OverlayInstances")` instead */
+    getOverlayInstances: () => string[];
+    /** @deprecated Use `saveSetting("OverlayInstances", value)` instead */
+    setOverlayInstances: (value: string[]) => void;
+    /** @deprecated Use `getSetting("BackupKeepAll")` instead */
+    backupKeepAll: () => boolean;
+    /** @deprecated Use `getSetting("BackupOnExit")` instead */
+    backupOnExit: () => boolean;
+    /** @deprecated Use `getSetting("BackupBeforeUpdates")` instead */
+    backupBeforeUpdates: () => boolean;
+    /** @deprecated Use `getSetting("BackupOnceADay")` instead */
+    backupOnceADay: () => boolean;
+    /** @deprecated Use `saveSetting("BackupOnceADay", value)` instead */
+    setBackupOnceADay: (value: boolean) => void;
+    /** @deprecated Use `getSetting("LastBackupDate")` instead */
+    lastBackupDate: () => Date;
+    /** @deprecated Use `saveSetting("LastBackupDate", value)` instead */
+    setLastBackupDate: (value: Date) => void;
+    /** @deprecated Use `getSetting("MaxBackupCount")` instead */
+    maxBackupCount: () => number | "All";
+    /** @deprecated Use `getSetting("MaxBackupCount")` instead */
+    setMaxBackupCount: (value: number) => void;
+    /** @deprecated Use `getSetting("AllowQuoteCSVDownloads")` instead */
+    getAllowQuoteCSVDownloads: () => boolean;
+    /** @deprecated Use `getSetting("ActiveChatUserListTimeout")` instead */
+    getActiveChatUserListTimeout: () => number;
+    /** @deprecated Use `getSetting("WebServerPort")` instead */
+    getWebSocketPort: () => number;
+    /** @deprecated Use `getSetting("WebServerPort")` instead */
+    getWebServerPort: () => number;
+    /** @deprecated Use `getSetting("ViewerDB")` instead */
+    getViewerDbStatus: () => boolean;
+    /** @deprecated Use `getSetting("AutoUpdateLevel")` instead */
+    getAutoUpdateLevel: () => FirebotAutoUpdateLevel;
+    /** @deprecated Use `getSetting("AudioOutputDevice")` instead */
+    getAudioOutputDevice: () => import("../../types/settings").FirebotAudioDevice;
+    /** @deprecated Use `getSetting("DebugMode")` instead */
+    debugModeEnabled: () => boolean;
+    /** @deprecated Use `getSetting("WhileLoopEnabled")` instead */
+    getWhileLoopEnabled: () => boolean;
+    /** @deprecated Use `saveSetting("WhileLoopEnabled", value)` instead */
+    setWhileLoopEnabled: (value: boolean) => void;
+    /** @deprecated Use `getSetting("SidebarControlledServices")` instead */
+    getSidebarControlledServices: () => string[];
+    /** @deprecated Use `getSetting("MinimizeToTray")` instead */
+    getMinimizeToTray: () => boolean;
+    /** @deprecated Use `saveSetting("MinimizeToTray", value)` instead */
+    setMinimizeToTray: (value: boolean) => void;
+}
+declare const settings: SettingsManager;
+export { settings as SettingsManager };

package/backend/counters/counter-manager.d.ts

@@ -0,0 +1,29 @@
+import type { Counter } from "../../types/counters";
+import JsonDbManager from "../database/json-db-manager";
+declare class CounterManager extends JsonDbManager<Counter> {
+    constructor();
+    /**
+     * @deprecated Please use {@linkcode getItem()} instead.
+     */
+    getCounter(counterId: string): Counter;
+    /**
+     * @deprecated Please use {@linkcode getItemByName()} instead.
+     */
+    getCounterByName(counterName: string): Counter;
+    saveItem(counter: Counter): Counter;
+    deleteItem(counterId: string): boolean;
+    private _updateCounterWidgets;
+    triggerUiRefresh(): void;
+    createCounter(counterName: string): Counter;
+    getCounterTxtFilePath(counterName: string): string;
+    updateCounterTxtFile(counterName: string, counterValue: number): Promise<void>;
+    renameCounterTxtFile(oldName: string, newName: string): Promise<void>;
+    deleteCounterTxtFile(counterName: string): Promise<void>;
+    private _counterHitMin;
+    private _counterHitMax;
+    private _runEffects;
+    private _updateCounter;
+    updateCounterValue(counterId: string, value: string | number, overridePreviousValue?: boolean): Promise<void>;
+}
+declare const counterManager: CounterManager;
+export { counterManager as CounterManager };