@crowbartools/firebot-types 5.67.0-alpha4 → 5.67.0-alpha6

package/backend/crowbar-relay/crowbar-relay-websocket.d.ts

@@ -0,0 +1,15 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+declare class CrowbarRelayWebSocket extends TypedEmitter<{
+    "ready": () => void;
+    "message": (msg: {
+        event: string;
+        data: unknown;
+    }) => void;
+}> {
+    private ws;
+    constructor();
+    private start;
+    send(event: string, data?: unknown): void;
+}
+export declare const crowbarRelayWebSocket: CrowbarRelayWebSocket;
+export {};

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

@@ -0,0 +1,25 @@
+import EventEmitter from "events";
+import { JsonDB } from "node-json-db";
+import { Currency } from "../../types/currency";
+import { FirebotViewer } from "../../types/viewers";
+type CurrencyCache = {
+    [currencyName: string]: Currency;
+};
+declare class CurrencyAccess extends EventEmitter {
+    private _currencyCache;
+    constructor();
+    isViewerDBOn(): boolean;
+    getCurrencyDb(): JsonDB;
+    loadCurrencies(): void;
+    getCurrencies(): CurrencyCache;
+    getCurrencyById(id: string): Currency;
+    getCurrencyByName(name: string): Currency;
+    addCurrencyToNewViewer(viewer: FirebotViewer): FirebotViewer;
+    importCurrency(currency: Currency): void;
+    createCurrency(currency: Currency): boolean;
+    updateCurrency(currency: Currency): void;
+    deleteCurrency(id: string): void;
+    private saveAllCurrencies;
+}
+declare const currencyAccess: CurrencyAccess;
+export default currencyAccess;

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

@@ -0,0 +1,29 @@
+import type { SystemCommand } from "../../types/commands";
+import type { Currency } from "../../types/currency";
+type CurrencyCommandRefreshRequestAction = "create" | "update" | "delete";
+declare class CurrencyCommandManager {
+    constructor();
+    /**
+     * Creates a command definition when given a currency name.
+     */
+    createCurrencyCommandDefinition(currency: Partial<Currency>): SystemCommand<{
+        currencyBalanceMessageTemplate: string;
+        whisperCurrencyBalanceMessage: boolean;
+        addMessageTemplate: string;
+        setMessageTemplate: string;
+        removeMessageTemplate: string;
+        addAllMessageTemplate: string;
+        removeAllMessageTemplate: string;
+    }>;
+    /**
+     * Makes sure our currency system commands are up to date.
+     */
+    refreshCurrencyCommands(action?: CurrencyCommandRefreshRequestAction, currency?: Partial<Currency>): void;
+    /**
+     * Loops through all currencies we have and passes them to refresh currency commands.
+     * This lets us create all of our currency commands when the application is started.
+     */
+    createAllCurrencyCommands(): void;
+}
+declare const currencyCommandManager: CurrencyCommandManager;
+export = currencyCommandManager;

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

@@ -0,0 +1,33 @@
+import { FirebotViewer } from "../../types/viewers";
+import { Currency } from "../../types/currency";
+declare class CurrencyManager {
+    private _currencyInterval;
+    constructor();
+    /**
+     * Adjust Currency
+     * This adjust currency for a viewer. Can be given negative values. Provide it with the database record for a viewer.
+     */
+    adjustCurrency(viewer: FirebotViewer, currencyId: string, value: number | string, adjustType?: string): Promise<void>;
+    purgeCurrencyById(currencyId: string): Promise<void>;
+    deleteCurrencyById(currencyId: string): Promise<void>;
+    startTimer(): void;
+    stopTimer(): void;
+    applyCurrency(): Promise<void>;
+    processCurrencyTimer(currency: Currency, basePayout: number): Promise<void>;
+    adjustCurrencyForViewer(username: string, currencyId: string, value: number | string, adjustType?: string): Promise<boolean>;
+    adjustCurrencyForViewerById(userId: string, currencyId: string, value: string | number, overrideValue?: boolean): Promise<boolean>;
+    addCurrencyToViewerGroupOnlineViewers(roleIds: string[], currencyId: string, value: string | number, ignoreDisable?: boolean, adjustType?: string): Promise<void>;
+    addCurrencyToOnlineViewers(currencyId: string, value: string | number, ignoreDisable?: boolean, adjustType?: string): Promise<void>;
+    /**
+     * Adjusts currency for all viewers in the database
+     */
+    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>;
+    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>;
+    getTopCurrencyHolders(currencyIdOrName: string, count: number, byName?: boolean): Promise<FirebotViewer[]>;
+}
+declare const currencyManager: CurrencyManager;
+export = currencyManager;

package/backend/custom-scripts/executors/effect-script-executor.d.ts

@@ -0,0 +1,22 @@
+import { ScriptBase, LegacyCustomScript, ScriptContext, ScriptDetails, EffectList } from "../../../types";
+import { IEffectScriptExecutor, EffectScriptExecutionResult } from "./script-executor.interface";
+/**
+ * Executor for new-spec EffectScripts (manifest.type === "script")
+ */
+export declare class EffectScriptExecutor extends IEffectScriptExecutor {
+    constructor();
+    canHandle(script: ScriptBase | LegacyCustomScript): boolean;
+    getScriptDetails(script: ScriptBase | LegacyCustomScript): ScriptDetails | null;
+    executeScript(script: ScriptBase | LegacyCustomScript, context: ScriptContext): Promise<EffectScriptExecutionResult>;
+    private isEffectScript;
+}
+/**
+ * Runs effects returned by a custom script and returns flow-control flags.
+ */
+export declare function runEffectsResult(effects: EffectList | Array<{
+    id?: string;
+    type?: string;
+}>, context: ScriptContext, onEffectsDone?: () => unknown): Promise<{
+    stop: boolean;
+    bubbleStop: boolean;
+} | undefined>;

package/backend/custom-scripts/executors/legacy-effect-script-executor.d.ts

@@ -0,0 +1,12 @@
+import { ScriptBase, LegacyCustomScript, ScriptContext, ScriptDetails } from "../../../types";
+import { IEffectScriptExecutor, EffectScriptExecutionResult } from "./script-executor.interface";
+/**
+ * Executor for legacy effect scripts (run function with no manifest or startupOnly !== true)
+ */
+export declare class LegacyEffectScriptExecutor extends IEffectScriptExecutor {
+    constructor();
+    canHandle(script: ScriptBase | LegacyCustomScript): Promise<boolean>;
+    getScriptDetails(script: ScriptBase | LegacyCustomScript): Promise<ScriptDetails | null>;
+    executeScript(script: ScriptBase | LegacyCustomScript, context: ScriptContext): Promise<EffectScriptExecutionResult>;
+    private isLegacy;
+}

package/backend/custom-scripts/executors/legacy-startup-script-executor.d.ts

@@ -0,0 +1,15 @@
+import { ScriptBase, LegacyCustomScript, InstalledPluginConfig, ScriptDetails } from "../../../types";
+import { IPluginExecutor, PluginExecutionResult } from "./script-executor.interface";
+/**
+ * Executor for legacy startup scripts (scripts that export a getScriptManifest function that returns an object with startupOnly: true)
+ */
+export declare class LegacyStartUpScript extends IPluginExecutor {
+    constructor();
+    canHandle(script: ScriptBase | LegacyCustomScript): Promise<boolean>;
+    executePlugin(script: ScriptBase | LegacyCustomScript, config: InstalledPluginConfig): Promise<PluginExecutionResult>;
+    unloadPlugin(script: ScriptBase | LegacyCustomScript): Promise<void>;
+    updateParameters(script: ScriptBase | LegacyCustomScript, config: InstalledPluginConfig): Promise<void>;
+    getScriptDetails(script: ScriptBase | LegacyCustomScript): Promise<ScriptDetails>;
+    private buildParameters;
+    private isLegacyScript;
+}

package/backend/custom-scripts/executors/plugin-executor.d.ts

@@ -0,0 +1,17 @@
+import { ScriptBase, LegacyCustomScript, Plugin, InstalledPluginConfig, ScriptDetails } from "../../../types";
+import { IPluginExecutor, PluginRegistrations, PluginExecutionResult } from "./script-executor.interface";
+/**
+ * Executor for new-spec Plugins (manifest.type === "plugin")
+ */
+export declare class PluginExecutor extends IPluginExecutor {
+    constructor();
+    canHandle(script: ScriptBase | LegacyCustomScript): script is Plugin<import("../../../types").FirebotParams>;
+    getScriptDetails(script: ScriptBase | LegacyCustomScript): ScriptDetails | null;
+    executePlugin(script: ScriptBase | LegacyCustomScript, config: InstalledPluginConfig, isInstalling?: boolean): Promise<PluginExecutionResult>;
+    unloadPlugin(script: ScriptBase | LegacyCustomScript, config: InstalledPluginConfig, registrations?: PluginRegistrations, isUninstalling?: boolean): Promise<void>;
+    updateParameters(script: ScriptBase | LegacyCustomScript, config: InstalledPluginConfig): Promise<void>;
+    private registerAll;
+    private runUnregistrations;
+    private buildParameters;
+    private isPlugin;
+}

package/backend/custom-scripts/executors/script-executor.interface.d.ts

@@ -0,0 +1,42 @@
+import { InstalledPluginConfig, LegacyCustomScript, ScriptBase, ScriptContext, Awaitable, ScriptDetails } from "../../../types";
+declare abstract class IBaseScriptExecutor {
+    abstract canHandle(script: ScriptBase | LegacyCustomScript): Awaitable<boolean>;
+    abstract getScriptDetails(script: ScriptBase | LegacyCustomScript): Awaitable<ScriptDetails | null>;
+}
+export interface PluginRegistrations {
+    effectIds?: string[];
+    variableHandles?: string[];
+    eventSourceIds?: string[];
+    filterIds?: string[];
+    systemCommandIds?: string[];
+    restrictionIds?: string[];
+    integrationIds?: string[];
+    gameIds?: string[];
+    uiExtensionIds?: string[];
+}
+export type PluginExecutionResult = {
+    success: true;
+    registrations?: PluginRegistrations;
+} | {
+    success: false;
+    error: string;
+};
+export declare abstract class IPluginExecutor extends IBaseScriptExecutor {
+    abstract executePlugin(script: ScriptBase | LegacyCustomScript, config: InstalledPluginConfig, isInstalling?: boolean): Awaitable<PluginExecutionResult>;
+    abstract unloadPlugin(script: ScriptBase | LegacyCustomScript, config: InstalledPluginConfig, registrations?: PluginRegistrations, isUninstalling?: boolean): Awaitable<void>;
+    updateParameters?(script: ScriptBase | LegacyCustomScript, config: InstalledPluginConfig): Awaitable<void>;
+}
+export type EffectScriptExecutionResult = {
+    success: true;
+    execution?: {
+        stop: boolean;
+        bubbleStop: boolean;
+    };
+} | {
+    success: false;
+    error: string;
+};
+export declare abstract class IEffectScriptExecutor extends IBaseScriptExecutor {
+    abstract executeScript(script: ScriptBase | LegacyCustomScript, context: ScriptContext): Awaitable<EffectScriptExecutionResult>;
+}
+export {};

package/backend/custom-scripts/plugin-config-manager.d.ts

@@ -0,0 +1,12 @@
+import { InstalledPluginConfig } from "../../types/plugins.js";
+import JsonDbManager from "../database/json-db-manager.js";
+/**
+ * Manages installed plugins (previously known as "start up scripts")
+ */
+declare class PluginConfigManager extends JsonDbManager<InstalledPluginConfig> {
+    constructor();
+    loadItems(): void;
+    migrateLegacyStartUpScriptsToPlugins(): void;
+}
+declare const manager: PluginConfigManager;
+export { manager as PluginConfigManager };

package/backend/custom-scripts/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/custom-scripts/script-api/context.d.ts

@@ -0,0 +1,44 @@
+import type { Manifest, InstalledPluginConfig } from "../../../types/plugins";
+import logger from "../../logwrapper";
+import { DisposeBag, DisposeFn } from "./internal/dispose-bag";
+import { normalizeName } from "./internal/name-normalizer";
+/**
+ * The per-script context handed to every namespace factory.
+ *
+ * `manifest` is populated after the script is first loaded. Shim methods should read `ctx.manifest`
+ * lazily (inside method bodies) instead of at factory time.
+ */
+export interface ScriptApiContext {
+    /** If a plugin, the installed config id.  */
+    readonly pluginId?: string;
+    /**
+     * Normalized, filesystem-safe scope id for this plugin/script.
+     */
+    readonly scriptId: string;
+    /** The on-disk filename of the script. */
+    readonly fileName: string;
+    /** Manifest, once known. Undefined during very-early loading. */
+    readonly manifest: Manifest | undefined;
+    /** Human-friendly display name. Manifest name when available, else fileName. */
+    readonly displayName: string;
+    /** Absolute path to this script's data directory. */
+    readonly scriptDataDir: string;
+    /** Winston child logger pre-tagged with `{ script: scriptId }`. */
+    readonly logger: typeof logger;
+    /** Register a teardown callback fired when the plugin is unloaded. */
+    onDispose(fn: DisposeFn): void;
+}
+export interface ScriptApiContextHandle {
+    readonly context: ScriptApiContext;
+    readonly disposeBag: DisposeBag;
+    setManifest(manifest: Manifest | undefined): void;
+}
+export type ScriptApiContextSource = {
+    kind: "plugin";
+    config: InstalledPluginConfig;
+} | {
+    kind: "effect-script";
+    fileName: string;
+};
+export declare function createScriptApiContext(source: ScriptApiContextSource): ScriptApiContextHandle;
+export { normalizeName };

package/backend/custom-scripts/script-api/index.d.ts

@@ -0,0 +1,8 @@
+import type { FirebotScriptApi } from "../../../types/script-api";
+import type { ScriptApiContext } from "./context";
+/**
+ * Composition root for the Firebot Script API
+ */
+export declare function buildScriptApi(ctx: ScriptApiContext): FirebotScriptApi;
+export type { ScriptApiContext, ScriptApiContextSource } from "./context";
+export { createScriptApiContext } from "./context";

package/backend/custom-scripts/script-api/internal/define-namespace.d.ts

@@ -0,0 +1,3 @@
+import type { ScriptApiContext } from "../context";
+export type ScriptApiNamespaceFactory<TApi> = (ctx: ScriptApiContext) => TApi;
+export declare function defineScriptApiNamespace<TApi>(factory: ScriptApiNamespaceFactory<TApi>): ScriptApiNamespaceFactory<TApi>;

package/backend/custom-scripts/script-api/internal/dispose-bag.d.ts

@@ -0,0 +1,13 @@
+export type DisposeFn = () => void | Promise<void>;
+/**
+ * Collects teardown callbacks registered by script-api namespaces during plugin
+ * startup, and drains them (in reverse order / LIFO) when the plugin is unloaded.
+ */
+export declare class DisposeBag {
+    private readonly label;
+    private fns;
+    private drained;
+    constructor(label: string);
+    add(fn: DisposeFn): void;
+    drain(): Promise<void>;
+}

package/backend/custom-scripts/script-api/internal/name-normalizer.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Normalizes a script name or file name into a slug safe for use
+ * as a stable identifier.
+ */
+export declare function normalizeName(value: string | undefined | null): string;

package/backend/custom-scripts/script-api/internal/script-data-dir.d.ts

@@ -0,0 +1 @@
+export declare function resolveScriptDataDir(scriptId: string): string;

package/backend/custom-scripts/script-api/namespaces/effects.d.ts

@@ -0,0 +1,2 @@
+import type { ScriptEffectsApi } from "../../../../types/script-api";
+export declare const createEffectsApi: import("../internal/define-namespace").ScriptApiNamespaceFactory<ScriptEffectsApi>;

package/backend/custom-scripts/script-api/namespaces/events.d.ts

@@ -0,0 +1,2 @@
+import type { ScriptEventsApi } from "../../../../types/script-api";
+export declare const createEventsApi: import("../internal/define-namespace").ScriptApiNamespaceFactory<ScriptEventsApi>;

package/backend/custom-scripts/script-api/namespaces/frontend-communicator.d.ts

@@ -0,0 +1,2 @@
+import type { ScriptFrontendCommunicatorApi } from "../../../../types/script-api";
+export declare const createFrontendCommunicatorApi: import("../internal/define-namespace").ScriptApiNamespaceFactory<ScriptFrontendCommunicatorApi>;

package/backend/custom-scripts/script-api/namespaces/logger.d.ts

@@ -0,0 +1,2 @@
+import type { ScriptLoggerApi } from "../../../../types/script-api";
+export declare const createLoggerApi: import("../internal/define-namespace").ScriptApiNamespaceFactory<ScriptLoggerApi>;

package/backend/custom-scripts/script-api/namespaces/storage.d.ts

@@ -0,0 +1,6 @@
+import type { ScriptStorageApi } from "../../../../types/script-api";
+/**
+ * Simple per-script storage. Lets a script easily save/load JSON values or
+ * arbitrary files inside its own data directory.
+ */
+export declare const createStorageApi: import("../internal/define-namespace").ScriptApiNamespaceFactory<ScriptStorageApi>;

package/backend/custom-scripts/script-api/namespaces/twitch.d.ts

@@ -0,0 +1,2 @@
+import type { ScriptTwitchApi } from "../../../../types/script-api";
+export declare const createTwitchApi: import("../internal/define-namespace").ScriptApiNamespaceFactory<ScriptTwitchApi>;

package/backend/custom-scripts/script-api/namespaces/webhooks.d.ts

@@ -0,0 +1,2 @@
+import type { ScriptWebhooksApi } from "../../../../types/script-api";
+export declare const createWebhooksApi: import("../internal/define-namespace").ScriptApiNamespaceFactory<ScriptWebhooksApi>;

package/backend/custom-scripts/script-manager.d.ts

@@ -0,0 +1,100 @@
+import { InstalledPlugin, InstalledPluginConfig, ScriptDetails, ScriptType, Trigger } from "../../types";
+import { EffectScriptExecutionResult } from "./executors/script-executor.interface";
+type GetScriptDetailsResult = {
+    success: true;
+    fileName: string;
+    scriptType: "plugin" | "script";
+    details: ScriptDetails;
+} | {
+    success: false;
+    error: string;
+};
+declare class ScriptManager {
+    private activePlugins;
+    private pendingApiInstances;
+    private effectScriptApiInstances;
+    private startingPlugins;
+    private requireInterceptorInstalled;
+    private pluginExecutors;
+    private effectScriptExecutors;
+    constructor();
+    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 script 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): Promise<void>;
+    setPluginEnabled(pluginId: string, enabled: boolean): Promise<void>;
+    getInstalledPlugins(): Promise<InstalledPlugin[]>;
+    /**
+     * Loads a script file (without persisting a config) and returns its details for
+     * the install / edit UI.
+     */
+    getScriptDetailsByFileName(fileName: string, expectedScriptType?: ScriptType): Promise<GetScriptDetailsResult>;
+    /**
+     * 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.
+     */
+    installScriptFromPath(sourcePath: string, overwrite?: boolean): Promise<GetScriptDetailsResult | {
+        success: false;
+        error: string;
+        conflict?: boolean;
+    }>;
+    /**
+     * Delete a copied script 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>;
+    deleteScriptFileIfUnreferenced(fileName: string): Promise<void>;
+    /**
+     * Remove an installed plugin. Stops the plugin and deletes its config, and
+     * optionally deletes the underlying script file from the scripts folder.
+     */
+    deletePlugin(pluginId: string, deleteScriptFile?: boolean): Promise<boolean>;
+    /**
+     * Replace the underlying script file for an existing plugin config with a new file
+     * chosen on disk.
+     */
+    updatePluginFromPath(pluginId: string, sourcePath: string, overwrite?: boolean): Promise<GetScriptDetailsResult | {
+        success: false;
+        error: string;
+        conflict?: boolean;
+    }>;
+    runEffectScript(effectData: {
+        scriptName: string;
+        parameters?: Record<string, unknown>;
+    }, trigger?: Trigger): Promise<EffectScriptExecutionResult | undefined>;
+    private disposeEffectScriptApi;
+    private getScriptFilePath;
+    private getActivePluginByFileName;
+    private findPluginExecutor;
+    private installRequireInterceptor;
+    private createApiInstance;
+    private loadScript;
+    /**
+     * Hack to load a script without registering it in `require.cache`.
+     *
+     * Used for read-only inspection (manifest / parameter schema lookup) so that
+     * loading a fresh copy of a script does not evict or replace the cached module
+     * of a currently-running plugin is holding a reference to.
+     */
+    private loadScriptIsolated;
+    private scriptCanBePlugin;
+}
+declare const scriptManager: ScriptManager;
+export default scriptManager;
+export { ScriptManager };

package/backend/database/json-db-manager.d.ts

@@ -0,0 +1,41 @@
+import type { JsonDB } from "node-json-db";
+import { TypedEmitter, type ListenerSignature } from "tiny-typed-emitter";
+interface Item {
+    id?: string;
+    name?: string;
+    [key: string]: unknown;
+}
+type DefaultEvents<I extends Item = Item> = {
+    "loaded-items": (items: I[]) => void;
+    "created-item": (item: I) => void;
+    "updated-item": (item: I) => void;
+    "saved-all-items": (items: I[]) => void;
+    "deleted-item": (item: I) => void;
+    "deleted-all-items": () => void;
+    "items-changed": (items: I[]) => void;
+};
+declare abstract class JsonDbManager<T extends Item, E extends ListenerSignature<E> = DefaultEvents<T>> extends TypedEmitter<E & DefaultEvents<T>> {
+    protected type: string;
+    protected path: string;
+    protected items: {
+        [key: string]: T;
+    };
+    protected db: JsonDB;
+    private batchedSaveTimeout;
+    /**
+     * @param type - The type of data in the json file
+     * @param path - The path to the json file
+     */
+    constructor(type: string, path: string);
+    loadItems(): void;
+    getItem(itemId: string): T | null;
+    getItemByName(itemName: string): T | null;
+    getAllItems(): T[];
+    saveItem(item: T, isCreating?: boolean, batchSave?: boolean): T | null;
+    saveAllItems(allItems: T[]): void;
+    private saveCurrentItems;
+    deleteItem(itemId: string): boolean;
+    deleteAllItems(): void;
+    private emitItemsChanged;
+}
+export = JsonDbManager;

package/backend/effects/builtin/active-user-lists.d.ts

@@ -0,0 +1,6 @@
+import { EffectType } from '../../../types/effects';
+declare const effect: EffectType<{
+    action: string;
+    username: string;
+}>;
+export = effect;

package/backend/effects/builtin/activity-feed-alert.d.ts

@@ -0,0 +1,6 @@
+import type { EffectType } from "../../../types/effects";
+declare const effect: EffectType<{
+    message: string;
+    icon: string;
+}>;
+export = effect;

package/backend/effects/builtin/add-quote.d.ts

@@ -0,0 +1,7 @@
+import { EffectType } from "../../../types/effects";
+declare const effect: EffectType<{
+    creator: string;
+    originator: string;
+    text: string;
+}>;
+export = effect;

package/backend/effects/builtin/chat-feed-alert.d.ts

@@ -0,0 +1,6 @@
+import { EffectType } from '../../../types/effects';
+declare const effect: EffectType<{
+    message: string;
+    icon: string;
+}>;
+export = effect;

package/backend/effects/builtin/chat-feed-custom-highlight.d.ts

@@ -0,0 +1,9 @@
+import { EffectType } from "../../../types/effects";
+declare const effect: EffectType<{
+    highlightEnabled: boolean;
+    bannerEnabled: boolean;
+    customHighlightColor?: string;
+    customBannerText?: string;
+    customBannerIcon?: string;
+}>;
+export = effect;

package/backend/effects/builtin/chat-feed-message-hide.d.ts

@@ -0,0 +1,5 @@
+import { EffectType } from "../../../types/effects";
+declare const effect: EffectType<{
+    hidden: boolean;
+}>;
+export = effect;

package/backend/effects/builtin/chat.d.ts

@@ -0,0 +1,9 @@
+import { EffectType } from '../../../types/effects';
+declare const effect: EffectType<{
+    chatter: string;
+    message: string;
+    me: boolean;
+    whisper: string;
+    sendAsReply: boolean;
+}>;
+export = effect;

package/backend/effects/builtin/clear-chat.d.ts

@@ -0,0 +1,3 @@
+import { EffectType } from '../../../types/effects';
+declare const effect: EffectType;
+export = effect;

package/backend/effects/builtin/clear-effects.d.ts

@@ -0,0 +1,11 @@
+import { EffectType } from "../../../types/effects";
+declare const effect: EffectType<{
+    overlay: boolean;
+    overlayInstance: string;
+    sounds: boolean;
+    queues: boolean;
+    queueId: string;
+    abortActiveQueueEffectLists: boolean;
+    activeEffectLists: boolean;
+}>;
+export = effect;

package/backend/effects/builtin/comment.d.ts

@@ -0,0 +1,5 @@
+import type { EffectType } from "../../../types/effects";
+declare const effect: EffectType<{
+    effectComment: string;
+}>;
+export = effect;

package/backend/effects/builtin/conditional-effects/switch-statement.d.ts

@@ -0,0 +1,18 @@
+import { EffectType } from "../../../../types/effects";
+interface SwitchCase {
+    label?: string;
+    type?: "compare" | "range";
+    value?: string;
+    min?: string;
+    max?: string;
+    effectList?: unknown;
+    fallthrough?: boolean;
+}
+interface EffectModel {
+    value: string;
+    cases: SwitchCase[];
+    defaultCase: SwitchCase;
+    bubbleOutputs: boolean;
+}
+declare const model: EffectType<EffectModel>;
+export = model;

package/backend/effects/builtin/copy-to-clipboard.d.ts

@@ -0,0 +1,5 @@
+import { EffectType } from "../../../types/effects";
+declare const effect: EffectType<{
+    text: string;
+}>;
+export = effect;

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

@@ -0,0 +1,9 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    name: string;
+    variableData: string;
+    ttl: number;
+    propertyPath: string;
+    persistToFile?: boolean;
+}>;
+export = effect;

package/backend/effects/builtin/delay.d.ts

@@ -0,0 +1,5 @@
+import type { EffectType } from "../../../types/effects";
+declare const effect: EffectType<{
+    delay: number;
+}>;
+export = effect;

package/backend/effects/builtin/delete-chat-message.d.ts

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