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

package/backend/effects/builtin/moderator-purge.d.ts

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

package/backend/effects/builtin/moderator-timeout.d.ts

@@ -0,0 +1,7 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    username: string;
+    time: number;
+    reason: string;
+}>;
+export = effect;

package/backend/effects/builtin/overlay-alert.d.ts

@@ -0,0 +1,54 @@
+import type { EffectType, FirebotAudioDevice } from "../../../types";
+interface OverlayAlertEffect {
+    mediaType: "image" | "video" | "none";
+    imageSourceType: "local" | "url" | "folderRandom";
+    videoSourceType: "local" | "folderRandom";
+    imageFile?: string;
+    imageUrl?: string;
+    imageFolder?: string;
+    videoFile?: string;
+    videoFolder?: string;
+    mediaScale?: number;
+    muteVideo?: boolean;
+    videoVolume?: number;
+    text?: string;
+    font?: {
+        family: string;
+        size: number;
+        color: string;
+        weight: number;
+        italic: boolean;
+    };
+    textShadow?: boolean;
+    accentColor?: string;
+    accentBold?: boolean;
+    accentItalic?: boolean;
+    accentUnderline?: boolean;
+    autoAccentVariables?: boolean;
+    playSound?: boolean;
+    soundType?: "local" | "url" | "folderRandom";
+    soundFile?: string;
+    soundUrl?: string;
+    soundFolder?: string;
+    soundVolume?: number;
+    audioOutputDevice?: FirebotAudioDevice;
+    duration?: number;
+    position?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    enterAnimation?: string;
+    enterDuration?: number;
+    exitAnimation?: string;
+    exitDuration?: number;
+    inbetweenAnimation?: string;
+    inbetweenDelay?: number;
+    inbetweenDuration?: number;
+    inbetweenRepeat?: number;
+    overlayInstance?: string;
+    textPosition?: "below" | "above" | "left" | "right" | "overlay";
+}
+declare const effect: EffectType<OverlayAlertEffect>;
+export = effect;

package/backend/effects/builtin/overlay-widgets/send-message-to-custom-widget.d.ts

@@ -0,0 +1,7 @@
+import type { EffectType } from "../../../../types";
+declare const model: EffectType<{
+    customWidgetId: string;
+    messageName: string;
+    messageDataJson?: string;
+}>;
+export = model;

package/backend/effects/builtin/overlay-widgets/set-custom-widget-state.d.ts

@@ -0,0 +1,7 @@
+import type { EffectType } from "../../../../types";
+declare const model: EffectType<{
+    customWidgetId: string;
+    newStateJson?: string;
+    mergeWithExistingState?: boolean;
+}>;
+export = model;

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

@@ -0,0 +1,9 @@
+import type { EffectType } from "../../../../types";
+declare const model: EffectType<{
+    countdownWidgetId: string;
+    action: "add" | "subtract" | "set" | "change-mode";
+    mode?: "running" | "paused" | "toggle";
+    value?: string;
+    startIfPaused?: boolean;
+}>;
+export = model;

package/backend/effects/builtin/overlay-widgets/update-overlay-widget-settings.d.ts

@@ -0,0 +1,11 @@
+import type { EffectType, Position } from "../../../../types";
+declare const model: EffectType<{
+    widgetConfigId: string;
+    mode: "update" | "reset";
+    saveChanges?: boolean;
+    settings?: Record<string, unknown>;
+    position?: Position | null;
+    zIndex?: number | null;
+    overlayInstance?: string | null;
+}>;
+export = model;

package/backend/effects/builtin/overlay-widgets/update-progress-bar.d.ts

@@ -0,0 +1,7 @@
+import type { EffectType } from "../../../../types";
+declare const model: EffectType<{
+    progressBarWidgetId: string;
+    action: "increment" | "set";
+    value: string;
+}>;
+export = model;

package/backend/effects/builtin/pause-resume-effect-queue.d.ts

@@ -0,0 +1,7 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    effectQueue: string;
+    action: "Pause" | "Resume" | "Toggle";
+    runEffectsImmediatelyWhenPaused?: boolean;
+}>;
+export = effect;

package/backend/effects/builtin/play-sound.d.ts

@@ -0,0 +1,21 @@
+import type { EffectType, FirebotAudioDevice } from "../../../types";
+import { type SoundType } from "../../common/handlers/sound-handler";
+declare const model: EffectType<{
+    soundType: SoundType;
+    volume: number;
+    filepath: string;
+    folder: string;
+    url: string;
+    mimeType: string;
+    rawData: string;
+    overlayInstance: string;
+    audioOutputDevice: FirebotAudioDevice;
+    waitForSound: boolean;
+}, {
+    isUrl: boolean;
+    url: string;
+    filepath: string;
+    resourceToken: string;
+    volume: number;
+}>;
+export = model;

package/backend/effects/builtin/random-reddit-image.d.ts

@@ -0,0 +1,8 @@
+import type { EffectType, OverlayDimensions, OverlayEnterExitAnimations, OverlayInstance, OverlayPosition, OverlayRotation } from "../../../types";
+declare const model: EffectType<{
+    reddit: string;
+    show: string;
+    chatter: string;
+    length: number;
+} & OverlayDimensions & OverlayPosition & OverlayRotation & OverlayEnterExitAnimations & OverlayInstance>;
+export = model;

package/backend/effects/builtin/remove-user-metadata.d.ts

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

package/backend/effects/builtin/reset-timer.d.ts

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

package/backend/effects/builtin/retrigger-last-activity.d.ts

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

package/backend/effects/builtin/run-command.d.ts

@@ -0,0 +1,13 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    commandType: "system" | "custom";
+    commandId: string;
+    systemCommandId: string;
+    username: string;
+    args: string;
+    enforceRestrictions: boolean;
+    sendRestrictionFailureMessage: boolean;
+    /** @deprecated */
+    customCommandId: string;
+}>;
+export = effect;

package/backend/effects/builtin/run-program.d.ts

@@ -0,0 +1,9 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    programPath: string;
+    programArgs: string;
+    waitForFinish: boolean;
+    hideWindow: boolean;
+    runDetached: boolean;
+}>;
+export = effect;

package/backend/effects/builtin/send-custom-websocket-event.d.ts

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

package/backend/effects/builtin/set-active-control-deck.d.ts

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

package/backend/effects/builtin/set-default-control-deck.d.ts

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

package/backend/effects/builtin/set-output.d.ts

@@ -0,0 +1,9 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    data: string;
+    propertyPath?: string;
+    outputNames: {
+        customOutput: string;
+    };
+}>;
+export = effect;

package/backend/effects/builtin/set-user-metadata.d.ts

@@ -0,0 +1,8 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    username: string;
+    key: string;
+    propertyPath: string;
+    data: string;
+}>;
+export = effect;

package/backend/effects/builtin/show-text.d.ts

@@ -0,0 +1,45 @@
+import type { EffectType, OverlayPosition, OverlayRotation, OverlayEnterExitAnimations, OverlayInstance, FontOptions } from "../../../types";
+type ShowTextEffectModel = {
+    text: string;
+    fontOptions: FontOptions;
+    addDropShadow: boolean;
+    duration: number;
+    height: number;
+    width: number;
+    wrapText: boolean;
+    showDebugBorder: boolean;
+    justify: "flex-start" | "center" | "flex-end";
+    align: "flex-start" | "center" | "flex-end";
+} & OverlayPosition & OverlayRotation & OverlayEnterExitAnimations & OverlayInstance;
+type ShowTextEffectOverlayData = {
+    text: string;
+    fontOptions: FontOptions;
+    addDropShadow: boolean;
+    inbetweenAnimation: string;
+    inbetweenDelay: number;
+    inbetweenDuration: number;
+    inbetweenRepeat: number;
+    enterAnimation: string;
+    enterDuration: number;
+    exitAnimation: string;
+    exitDuration: number;
+    customCoords: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    position: string;
+    duration: number;
+    height: number;
+    width: number;
+    justify: "flex-start" | "center" | "flex-end";
+    align: "flex-start" | "center" | "flex-end";
+    wrapText: boolean;
+    showDebugBorder: boolean;
+    overlayInstance: string;
+    rotation: string;
+    zIndex: number;
+};
+declare const ShowTextEffect: EffectType<ShowTextEffectModel, ShowTextEffectOverlayData>;
+export = ShowTextEffect;

package/backend/effects/builtin/show-toast.d.ts

@@ -0,0 +1,8 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    alertType: "info" | "success" | "warning" | "danger";
+    message: string;
+    dismissType: "timeout" | "manual";
+    timeout: number;
+}>;
+export = effect;

package/backend/effects/builtin/stop-effect-execution.d.ts

@@ -0,0 +1,9 @@
+import type { EffectType } from "../../../types";
+declare const model: EffectType<{
+    target: "currentList" | "specificList" | "queueActiveEffectLists" | "allActiveEffectLists" | "specificEffect";
+    listId: string;
+    effectId: string;
+    queueId: string;
+    bubbleStop: boolean;
+}>;
+export = model;

package/backend/effects/builtin/sync-profile-data.d.ts

@@ -0,0 +1,5 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    profilePage: "commands" | "quotes";
+}>;
+export = effect;

package/backend/effects/builtin/take-screenshot.d.ts

@@ -0,0 +1,25 @@
+import type { EffectType, DiscordCustomEmbed } from "../../../types";
+import { type ScreenshotEffectData } from "../../common/screenshot-helpers";
+declare const effect: EffectType<{
+    displayId: number;
+    saveLocally: boolean;
+    overwriteExisting: boolean;
+    postInDiscord: boolean;
+    showInOverlay: boolean;
+    folderPath: string;
+    file: string;
+    discordChannelId: string;
+    embedType: unknown;
+    embedColor: string;
+    fileNamePattern: string;
+    message: string;
+    customEmbed: DiscordCustomEmbed;
+    width: number;
+    height: number;
+    position: string;
+    overlayInstance: string;
+    duration: number;
+}, ScreenshotEffectData & {
+    screenshotDataUrl: string;
+}>;
+export = effect;

package/backend/effects/builtin/text-to-speech.d.ts

@@ -0,0 +1,7 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    text: string;
+    voiceId: string;
+    wait?: boolean;
+}>;
+export = effect;

package/backend/effects/builtin/toggle-command.d.ts

@@ -0,0 +1,8 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    commandId: string;
+    toggleType: "disable" | "enable" | "toggle";
+    commandType: "system" | "custom" | "tag";
+    sortTagId?: string;
+}>;
+export = effect;

package/backend/effects/builtin/toggle-connection.d.ts

@@ -0,0 +1,11 @@
+import type { EffectType } from "../../../types";
+interface Service {
+    id: string;
+    action: boolean | "toggle";
+}
+declare const effect: EffectType<{
+    mode: "all" | "custom";
+    allAction: boolean | "toggle";
+    services: Service[];
+}>;
+export = effect;

package/backend/effects/builtin/toggle-event-set.d.ts

@@ -0,0 +1,6 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    selectedEventGroupId: string;
+    toggleType: "disable" | "enable";
+}>;
+export = effect;

package/backend/effects/builtin/toggle-event.d.ts

@@ -0,0 +1,7 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    selectedEventId: string;
+    selectedGroupName: string;
+    toggleType: "disable" | "enable" | "toggle";
+}>;
+export = effect;

package/backend/effects/builtin/toggle-overlay-widgets.d.ts

@@ -0,0 +1,6 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    mode: "toggle" | "disable" | "enable";
+    widgetConfigIds: string[];
+}>;
+export = effect;

package/backend/effects/builtin/toggle-scheduled-task.d.ts

@@ -0,0 +1,8 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    scheduledTaskId: string;
+    toggleType: "toggle" | "enable" | "disable";
+    useTag?: boolean;
+    sortTagId?: string;
+}>;
+export = effect;

package/backend/effects/builtin/toggle-timer.d.ts

@@ -0,0 +1,8 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    selectedTimerId?: string;
+    toggleType: "toggle" | "enable" | "disable";
+    useTag?: boolean;
+    sortTagId?: string;
+}>;
+export = effect;

package/backend/effects/builtin/trigger-manual-effect-queue.d.ts

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

package/backend/effects/builtin/update-channel-reward.d.ts

@@ -0,0 +1,25 @@
+import { EffectType } from "../../../types";
+type StringUpdatable = {
+    update: boolean;
+    newValue: string;
+};
+type StatusUpdatable = {
+    update: boolean;
+    newValue: 'toggle' | boolean;
+};
+type EffectMeta = {
+    rewardSettings: {
+        name: StringUpdatable;
+        description: StringUpdatable;
+        cost: StringUpdatable;
+        enabled: StatusUpdatable;
+        paused: StatusUpdatable;
+    };
+    rewardSelectMode: "dropdown" | "associated" | "sortTag" | "custom";
+    channelRewardId: string;
+    customId: string;
+    useTag?: boolean;
+    sortTagId?: string;
+};
+declare const effect: EffectType<EffectMeta>;
+export = effect;

package/backend/effects/builtin/update-counter.d.ts

@@ -0,0 +1,7 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    counterId: string;
+    mode: string;
+    value: string;
+}>;
+export = effect;

package/backend/effects/builtin/update-role.d.ts

@@ -0,0 +1,12 @@
+import type { EffectType } from "../../../types";
+/**
+ * The 'Update Role' effect
+ */
+declare const effect: EffectType<{
+    addRoleId: string;
+    customViewer: string;
+    removeRoleId: string;
+    removeAllRoleId: string;
+    viewerType: "current" | "custom";
+}>;
+export = effect;

package/backend/effects/builtin/update-viewer-rank.d.ts

@@ -0,0 +1,8 @@
+import type { EffectType } from "../../../types";
+declare const effect: EffectType<{
+    rankLadderId: string;
+    action: "promote" | "demote" | "set-specific-rank" | "set-variable-rank";
+    rankId?: string;
+    variableRankName?: string;
+}>;
+export = effect;

package/backend/effects/effect-helpers.d.ts

@@ -0,0 +1,5 @@
+import type { EffectType } from "../../types";
+type ValidationMode = "execution" | "display";
+export declare function setChatConnection(isConnected: boolean): void;
+export declare const checkEffectDependencies: (dependencies: EffectType<unknown>["definition"]["dependencies"], validateFor: ValidationMode) => boolean;
+export {};

package/backend/effects/effect-manager.d.ts

@@ -0,0 +1,70 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { EffectDefinition, EffectType, TriggersObject, TriggerType } from "../../types";
+declare class EffectManager extends TypedEmitter<{
+    "effectRegistered": (effect: EffectType<any>) => void;
+    "effectUnregistered": (event: {
+        effectId: string;
+        hasOverlayEffect: boolean;
+    }) => void;
+}> {
+    private logger;
+    private _registeredEffects;
+    private _additionalEffectEvents;
+    constructor();
+    registerEffect<T = unknown>(effect: EffectType<T>): void;
+    unregisterEffect(effectId: string): void;
+    getEffectDefinitions(): EffectDefinition<any>[];
+    getEffectById(id: any): EffectType<any>;
+    getEffectOverlayExtensions(): {
+        id: string;
+        dependencies: {
+            globalStyles?: string;
+            css?: string[];
+            js?: Array<string | {
+                module: boolean;
+                url: string;
+            }>;
+        };
+        event: {
+            name: string;
+            onOverlayEvent: (data: unknown) => void;
+        };
+    }[];
+    getEffectsForEvent(eventSourceId: string, eventId: string): EffectDefinition[];
+    addEventToEffect(effectId: string, eventSourceId: string, eventId: string): void;
+    removeEventFromEffect(effectId: string, eventSourceId: string, eventId: string): void;
+    mapEffectForFrontEnd(e: EffectType): {
+        definition?: undefined;
+        optionsTemplate?: undefined;
+        optionsTemplateUrl?: undefined;
+        optionsControllerRaw?: undefined;
+        optionsValidatorRaw?: undefined;
+        getDefaultLabelRaw?: undefined;
+    } | {
+        definition: {
+            hidden: boolean;
+            id: string;
+            name: string;
+            description: string;
+            icon: string;
+            categories: import("../../types").EffectCategory[];
+            deprecated?: boolean;
+            triggers?: TriggerType[] | TriggersObject;
+            dependencies?: import("../../types").EffectDependencies | Array<"chat">;
+            showWhenDependenciesNotMet?: boolean;
+            outputs?: import("../../types").EffectOutput[];
+            exemptFromTimeouts?: boolean;
+            exemptFromAsync?: boolean;
+            keysExemptFromAutoVariableReplacement?: never[];
+            isNoOp?: boolean;
+        };
+        optionsTemplate: string;
+        optionsTemplateUrl: string;
+        optionsControllerRaw: string;
+        optionsValidatorRaw: string;
+        getDefaultLabelRaw: string;
+    };
+    clearFilePaths(effects: unknown): unknown;
+}
+declare const manager: EffectManager;
+export { manager as EffectManager };

package/backend/effects/preset-lists/preset-effect-list-manager.d.ts

@@ -0,0 +1,8 @@
+import type { PresetEffectList } from "../../../types";
+import JsonDbManager from "../../database/json-db-manager";
+declare class PresetEffectListManager extends JsonDbManager<PresetEffectList> {
+    constructor();
+    triggerUiRefresh(): void;
+}
+declare const presetEffectListManager: PresetEffectListManager;
+export { presetEffectListManager as PresetEffectListManager };

package/backend/effects/queues/effect-queue-config-manager.d.ts

@@ -0,0 +1,17 @@
+import type { EffectQueueConfig } from "../../../types";
+import JsonDbManager from "../../database/json-db-manager";
+declare class EffectQueueConfigManager extends JsonDbManager<EffectQueueConfig> {
+    constructor();
+    loadItems(): void;
+    saveItem(effectQueueConfig: EffectQueueConfig): EffectQueueConfig;
+    saveAllItems(allItems: EffectQueueConfig[]): void;
+    getAllItems(): EffectQueueConfig[];
+    getItem(id: string): EffectQueueConfig;
+    triggerUiRefresh(): void;
+    private setQueueActiveStatus;
+    pauseQueue(queueId: string, runEffectsImmediatelyWhenPaused?: boolean): void;
+    resumeQueue(queueId: string): void;
+    toggleQueue(queueId: string, runEffectsImmediatelyWhenPaused?: boolean): void;
+}
+declare const manager: EffectQueueConfigManager;
+export { manager as EffectQueueConfigManager };

package/backend/effects/queues/effect-queue-runner.d.ts

@@ -0,0 +1,27 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { EffectQueueConfig, QueueState, RunEffectsContext } from "../../../types";
+import { EffectQueue } from "./effect-queue";
+type Events = {
+    "length-updated": (queueData: {
+        id: string;
+        length: number;
+    }) => void;
+    "queue-state-updated": (queueId: string, newState: QueueState, changedState: Partial<QueueState>) => void;
+};
+declare class EffectQueueRunner extends TypedEmitter<Events> {
+    private _queues;
+    constructor();
+    get queues(): Record<string, EffectQueue>;
+    getQueueStateForConfig(config: EffectQueueConfig): QueueState;
+    private _getQueue;
+    addEffectsToQueue(queueConfig: EffectQueueConfig, runEffectsContext: RunEffectsContext, duration?: number, priority?: "none" | "high"): void;
+    triggerQueue(queueId: string): void;
+    updateQueue(queueConfig: EffectQueueConfig): void;
+    removeQueue(queueId: string, abortActiveEffectLists?: boolean): void;
+    getQueueLength(queueId: string): number;
+    clearAllQueues(abortActiveEffectLists?: boolean): void;
+    abortActiveEffectListsForQueue(queueId: string, bubbleStop?: boolean): void;
+    abortActiveEffectListsForAllQueues(bubbleStop?: boolean): void;
+}
+declare const runner: EffectQueueRunner;
+export default runner;

package/backend/effects/queues/effect-queue.d.ts

@@ -0,0 +1,27 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { EffectQueueConfig, QueueState, RunEffectsContext } from "../../../types";
+type Events = {
+    "queue-state-updated": (newState: QueueState, changedState: Partial<QueueState>) => void;
+};
+export declare class EffectQueue extends TypedEmitter<Events> {
+    id: string;
+    private _state;
+    constructor(config: EffectQueueConfig);
+    private _setState;
+    get state(): QueueState;
+    get queueLength(): number;
+    private _runEffects;
+    private _runQueue;
+    addEffects(runEffectsContext: RunEffectsContext, duration?: number, priority?: "none" | "high"): void;
+    processEffectQueue(): void;
+    abortActiveEffectLists(bubbleStop?: boolean): void;
+    cancelQueue(abortActiveEffectLists: boolean): void;
+    pauseQueue(): void;
+    resumeQueue(): void;
+    updateConfig(config: EffectQueueConfig): void;
+    toJSON(): {
+        id: string;
+        state: QueueState;
+    };
+}
+export {};