@crowbartools/firebot-types 5.67.0-alpha1

package/types/restrictions.d.ts

@@ -0,0 +1,65 @@
+import type { Trigger, TriggerType, TriggersObject } from "./triggers";
+import type { Awaitable } from "./util-types";
+
+interface RestrictionScope<RestrictionModel> extends ng.IScope {
+    restriction: Restriction<RestrictionModel>;
+    restrictionDefinition: RestrictionType<RestrictionModel>;
+    restrictionMode: RestrictionMode;
+    [x: string]: any;
+}
+
+export type RestrictionMode = "all" | "any" | "none";
+
+export type RestrictionType<RestrictionModel = unknown> = {
+    definition: {
+        id: string;
+        name: string;
+        description: string;
+        triggers?: TriggerType[] | TriggersObject;
+    };
+    failedReasonWhenInverted?: string;
+    optionsTemplate: string;
+    optionsController?: (
+        $scope: RestrictionScope<RestrictionModel>,
+        ...args: any[]
+    ) => void;
+    optionsValueDisplay?: (
+        restriction: RestrictionModel,
+        ...args: any[]
+    ) => string;
+    predicate(
+        triggerData: Trigger,
+        restrictionData: RestrictionModel,
+        inherited?: boolean
+    ): Awaitable<boolean>;
+    onSuccessful?: (
+        triggerData: Trigger,
+        restrictionData: RestrictionModel,
+        inherited?: boolean
+    ) => Awaitable<void>;
+};
+
+export type Restriction<RestrictionModel = unknown> = {
+    id: string;
+    type: string;
+} & {
+    [K in keyof RestrictionModel]: RestrictionModel[K];
+} & {
+    [x: string]: unknown;
+};
+
+export type RestrictionData = {
+    /**
+     * Sets the command to only trigger when all/any/none of the restrictions pass.
+     */
+    mode?: RestrictionMode;
+    /**
+     * If a chat message should be sent when the restrictions are not met.
+     */
+    sendFailMessage?: boolean;
+    useCustomFailMessage?: boolean;
+    failMessage?: string;
+    restrictions: Restriction[];
+    sendAsReply?: boolean;
+    invertCondition?: boolean;
+};

package/types/roles.d.ts

@@ -0,0 +1,21 @@
+export interface FirebotRole {
+    id: string;
+    name: string;
+}
+
+export type CustomRole = {
+    id: string;
+    name: string;
+    viewers: Array<{
+        id: string;
+        username: string;
+        displayName: string;
+    }>;
+    showBadgeInChat?: boolean;
+};
+
+export type LegacyCustomRole = {
+    id: string;
+    name: string;
+    viewers: string[];
+};

package/types/script-api.d.ts

@@ -0,0 +1,95 @@
+/// <reference types="node" />
+
+// Public contract types for the Firebot Script API.
+//
+// Everything a custom script can touch via `require("@crowbartools/firebot-types")`
+// should be defined here
+
+export type ScriptLogMethod = (message: string, ...meta: unknown[]) => void;
+
+export interface ScriptLoggerApi {
+    debug: ScriptLogMethod;
+    info: ScriptLogMethod;
+    warn: ScriptLogMethod;
+    error: ScriptLogMethod;
+}
+
+export interface ScriptWebhook {
+    id: string;
+    name: string;
+}
+
+export interface ScriptWebhookEvent {
+    webhook: ScriptWebhook;
+    payload: unknown;
+    rawPayload?: string;
+    headers: Record<string, string>;
+}
+
+export type ScriptWebhookEventHandler = (event: ScriptWebhookEvent) => void;
+
+export interface ScriptWebhooksApi {
+    /** Create a new webhook (or return the existing one with the same name). */
+    save(name: string): ScriptWebhook | null;
+    /** Look up a webhook by name. */
+    get(name: string): ScriptWebhook | null;
+    /** Delete a webhook by name. Returns true if one was removed. */
+    delete(name: string): boolean;
+    /** All webhooks owned by this script. */
+    list(): ScriptWebhook[];
+    /** Public URL for a webhook by name, or null if not found. */
+    getUrl(name: string): string | null;
+    /**
+     * Subscribe to webhook events for this script. Returns an `unsubscribe` func
+     */
+    onReceived(handler: ScriptWebhookEventHandler): () => void;
+}
+
+export interface ScriptFsDirEntry {
+    /** File or directory name */
+    name: string;
+    /** Path relative to the script's data dir */
+    relativePath: string;
+    isFile: boolean;
+    isDirectory: boolean;
+}
+
+export interface ScriptFsApi {
+    /** Absolute path to this script's data directory. Read-only. */
+    readonly dataDir: string;
+
+    /** Resolve a sandboxed relative path to an absolute one. Throws on escape. */
+    resolve(relativePath: string): string;
+
+    exists(relativePath: string): Promise<boolean>;
+
+    readText(relativePath: string, encoding?: BufferEncoding): Promise<string>;
+    writeText(relativePath: string, contents: string, encoding?: BufferEncoding): Promise<void>;
+
+    readBytes(relativePath: string): Promise<Buffer>;
+    writeBytes(relativePath: string, contents: Buffer | Uint8Array): Promise<void>;
+
+    /** Read JSON. Returns `null` if the file doesn't exist. */
+    readJson(relativePath: string): Promise<unknown>;
+    /** Write JSON pretty-printed with 2-space indent. */
+    writeJson(relativePath: string, value: unknown): Promise<void>;
+
+    /** Create a directory (and any missing parents). */
+    mkdir(relativePath: string): Promise<void>;
+    /** Delete a file or directory recursively. No-op if it doesn't exist. */
+    remove(relativePath: string): Promise<void>;
+
+    /** List immediate children of a directory (defaults to the data dir root). */
+    list(relativePath?: string): Promise<ScriptFsDirEntry[]>;
+}
+
+export interface FirebotScriptApi {
+    /** Running Firebot version, e.g. `"5.65.0"`. */
+    version: string;
+    /** Scoped logger. */
+    logger: ScriptLoggerApi;
+    /** Webhooks owned by this script. */
+    webhooks: ScriptWebhooksApi;
+    /** Sandboxed filesystem rooted at this script's data directory. */
+    fs: ScriptFsApi;
+}

package/types/settings.d.ts

@@ -0,0 +1,131 @@
+export declare enum FirebotAutoUpdateLevel {
+    Off = 0,
+    Bugfix = 1,
+    Feature = 2,
+    MajorRelease = 3,
+    Betas = 4
+}
+export type FirebotAudioDevice = {
+    label: string;
+    deviceId: string;
+};
+export type FirebotGlobalValue = {
+    name: string;
+    secret?: boolean;
+    value: string;
+};
+export type FirebotSettingsTypes = {
+    ActiveChatUserListTimeout: number;
+    ActiveProfiles: string[];
+    AllowChatCreatedCommandsToRunEffects: boolean;
+    AllowCommandsInSharedChat: boolean;
+    AllowQuoteCSVDownloads: boolean;
+    AllowedActivityEvents: string[];
+    AudioOutputDevice: FirebotAudioDevice;
+    AutoFlagBots: boolean;
+    AutoUpdateLevel: FirebotAutoUpdateLevel;
+    BackupBeforeUpdates: boolean;
+    BackupIgnoreResources: boolean;
+    BackupKeepAll: boolean;
+    BackupLocation: string;
+    BackupLocationReset: boolean;
+    BackupOnceADay: boolean;
+    BackupOnExit: boolean;
+    ChatAlternateBackgrounds: boolean;
+    ChatAvatars: boolean;
+    ChatCompactMode: boolean;
+    ChatCustomFontFamily: string;
+    ChatCustomFontFamilyEnabled: boolean;
+    ChatCustomFontSize: number;
+    ChatCustomFontSizeEnabled: boolean;
+    ChatGetAllEmotes: boolean;
+    ChatHideBotAccountMessages: boolean;
+    ChatHideDeletedMessages: boolean;
+    ChatHideWhispers: boolean;
+    ChatPronouns: boolean;
+    ChatReverseOrder: boolean;
+    ChatShowBttvEmotes: boolean;
+    ChatShowFfzEmotes: boolean;
+    ChatShowSevenTvEmotes: boolean;
+    ChatShowSharedChatInfo: boolean;
+    ChatTaggedNotificationSound: {
+        name: string;
+        path?: string | undefined;
+    };
+    ChatTaggedNotificationVolume: number;
+    ChatTimestamps: boolean;
+    ClearChatFeedMode: "never" | "onlyStreamer" | "always";
+    ClearCustomScriptCache: boolean;
+    ConnectOnLaunch: boolean;
+    CopiedOverlayVersion: string;
+    DashboardLayout: {
+        dashboardViewerList: string;
+        dashboardChatWindow: string;
+        dashboardActivityFeed: string;
+    };
+    DebugMode: boolean;
+    DefaultEffectLabelsEnabled: boolean;
+    DefaultModerationUser: "streamer" | "bot";
+    DefaultRewardTab: "powerups" | "rewards" | "queue";
+    DefaultToAdvancedCommandMode: boolean;
+    DefaultTtsVoiceId: string;
+    DeleteProfile: string;
+    EventSetSettings: Record<string, {
+        position: number;
+    }>;
+    EventSettings: object;
+    FirstTimeUse: boolean;
+    ForceOverlayEffectsToContinueOnRefresh: boolean;
+    GlobalValues: Array<FirebotGlobalValue>;
+    IgnoreSubsequentSubEventsAfterCommunitySub: boolean;
+    JustUpdated: boolean;
+    LastBackupDate: Date;
+    LegacySortTagsImported: boolean;
+    LoggedInProfile: string;
+    MaxBackupCount: number | "All";
+    MinimizeToTray: boolean;
+    NotifyOnBeta: boolean;
+    OpenEffectQueueMonitorOnLaunch: boolean;
+    OpenStreamPreviewOnLaunch: boolean;
+    OverlayResolution: {
+        width: number;
+        height: number;
+    };
+    OverlayInstances: string[];
+    PersistCustomVariables: boolean;
+    PresetRecursionLimit: boolean;
+    QuickActions: Record<string, {
+        enabled: boolean;
+        position: number;
+    }>;
+    RunCustomScripts: boolean;
+    SeenAdvancedCommandModePopup: boolean;
+    ShowAdBreakIndicator: boolean;
+    ShowActivityFeed: boolean;
+    ShowActivityFeedEventsInChat: boolean;
+    ShowChatViewerList: boolean;
+    ShowHypeTrainIndicator: boolean;
+    ShowUptimeStat: boolean;
+    ShowViewerCountStat: boolean;
+    SidebarControlledServices: string[];
+    SidebarExpanded: boolean;
+    SoundsEnabled: "On" | "Off";
+    StreamerExemptFromCooldowns: boolean;
+    Theme: string;
+    TriggerUpcomingAdBreakMinutes: number;
+    TtsVoiceRate: number;
+    TtsVoiceVolume: number;
+    UseExperimentalTwitchClipUrlResolver: boolean;
+    UseOverlayInstances: boolean;
+    ViewerDB: boolean;
+    ViewerListPageSize: number;
+    WebhookDebugLogs: boolean;
+    WebOnlineCheckin: boolean;
+    WebServerPort: number;
+    WhileLoopEnabled: boolean;
+    WysiwygBackground: "black" | "white";
+};
+export declare const FirebotGlobalSettings: Partial<Record<keyof FirebotSettingsTypes, boolean>>;
+export declare const FirebotSettingsDefaults: FirebotSettingsTypes;
+/** Anything in `SettingsTypes` not listed here will resolve to "/settings/settingName" (e.g. "/settings/autoFlagBots") */
+export declare const FirebotSettingsPaths: Partial<Record<keyof FirebotSettingsTypes, string>>;

package/types/setups.d.ts

@@ -0,0 +1,49 @@
+import type { CommandDefinition } from "./commands";
+import type { Counter } from "./counters";
+import type { Currency } from "./currency";
+import type { EffectQueueConfig, PresetEffectList } from "./effects";
+import type { EventGroup, EventSettings } from "./events";
+import type { FirebotHotkey } from "./hotkeys";
+import type { OverlayWidgetConfig } from "./overlay-widgets";
+import type { QuickActionDefinition } from "./quick-actions";
+import type { RankLadder } from "./ranks";
+import type { CustomRole, LegacyCustomRole } from "./roles";
+import type { FirebotGlobalValue } from "./settings";
+import type { ScheduledTask, Timer } from "./timers";
+import type { VariableMacro } from "./variable-macros";
+
+export type SetupImportQuestion = {
+    replaceToken: string;
+    answer: string;
+};
+
+type FirebotSetupGlobalValue = FirebotGlobalValue & {
+    id: string;
+};
+
+export type FirebotSetup = {
+    name: string;
+    description: string;
+    author: string;
+    version: number;
+    importQuestions: SetupImportQuestion[];
+    requireCurrency: boolean;
+    components: {
+        commands: CommandDefinition[];
+        counters: Counter[];
+        currencies: Currency[];
+        effectQueues: EffectQueueConfig[];
+        events: EventSettings[];
+        eventGroups: EventGroup[];
+        hotkeys: FirebotHotkey[];
+        presetEffectLists: PresetEffectList[];
+        timers: Timer[];
+        scheduledTasks: ScheduledTask[];
+        variableMacros: VariableMacro[];
+        viewerRoles: (LegacyCustomRole | CustomRole)[];
+        viewerRankLadders: RankLadder[];
+        quickActions: QuickActionDefinition[];
+        overlayWidgetConfigs: OverlayWidgetConfig[];
+        globalValues: FirebotSetupGlobalValue[];
+    };
+};

package/types/sort-tags.d.ts

@@ -0,0 +1,4 @@
+export interface SortTag {
+    id: string;
+    name: string;
+}

package/types/timers.d.ts

@@ -0,0 +1,36 @@
+import type { DateTime } from "luxon";
+
+import type { EffectList } from "./effects";
+
+export type Timer = {
+    id: string;
+    name: string;
+    active: boolean;
+    interval: number;
+    requiredChatLines: number;
+    onlyWhenLive: boolean;
+    effects: EffectList;
+    sortTags: string[];
+};
+
+export type TimerIntervalTracker = {
+    timerId: string;
+    onlyWhenLive: boolean;
+    timer: Timer;
+    requiredChatLines: number;
+    waitingForChatLines: boolean;
+    chatLinesSinceLastRunCount: number;
+    intervalId: number | NodeJS.Timeout;
+    startedAt: DateTime;
+};
+
+export type ScheduledTask = {
+    id: string;
+    name: string;
+    enabled: boolean;
+    schedule: string;
+    inputType: string;
+    onlyWhenLive: boolean;
+    effects: EffectList;
+    sortTags: string[];
+};

package/types/triggers.d.ts

@@ -0,0 +1,61 @@
+import type { FirebotChatMessage } from "./chat";
+import type { CommandDefinition, SubCommand } from "./commands";
+
+export type TriggerType =
+    | "command"
+    | "custom_script"
+    | "startup_script"
+    | "api"
+    | "event"
+    | "hotkey"
+    | "timer"
+    | "scheduled_task"
+    | "counter"
+    | "preset"
+    | "quick_action"
+    | "manual"
+    | "channel_reward"
+    | "power_up"
+    | "overlay_widget";
+
+export type TriggerMeta = {
+    triggerId?: string;
+    [x: string]: unknown;
+};
+
+export type Trigger = {
+    type: TriggerType;
+    metadata: {
+        username: string;
+        hotkey?: unknown;
+        command?: CommandDefinition;
+        userCommand?: {
+            trigger: string;
+            args: string[];
+            triggeredArg?: string;
+            triggeredSubcmd?: SubCommand;
+            subcommandId?: string;
+        };
+        chatMessage?: FirebotChatMessage;
+        event?: { id: string, name: string };
+        eventSource?: { id: string, name: string };
+        eventData?: {
+            chatMessage?: FirebotChatMessage;
+            [x: string]: unknown;
+        };
+        counter?: {
+            id: string;
+            name: string;
+            previousValue: number;
+            value: number;
+            minimum?: number;
+            maximum?: number;
+        };
+        [x: string]: unknown;
+    };
+    effectOutputs?: { [key: string]: unknown };
+};
+
+export type TriggersObject = {
+    [T in TriggerType]?: T extends "event" ? string[] | boolean : boolean;
+};

package/types/ui/angular.d.ts

@@ -0,0 +1,31 @@
+import type angular from "angular";
+
+export type BindingsDefinition<Bindings> = {
+    [K in keyof Bindings]: {} extends Pick<Bindings, K>
+        ? Bindings[K] extends string
+            ? "@?" | "<?" | "=?" | `@?${string}` | `<?${string}` | `=?${string}`
+            : Bindings[K] extends boolean
+                ? "<?" | "=?" | `<?${string}` | `=?${string}`
+                : Bindings[K] extends number
+                    ? "<?" | "=?" | `<?${string}` | `=?${string}`
+                    : Bindings[K] extends (...args: any[]) => any
+                        ? "&?" | `&?${string}`
+                        : "<?" | "=?" | `<?${string}` | `=?${string}`
+        : Bindings[K] extends string
+            ? "@" | "<" | "=" | `@${string}` | `<${string}` | `=${string}`
+            : Bindings[K] extends boolean
+                ? "<" | "=" | `<${string}` | `=${string}`
+                : Bindings[K] extends number
+                    ? "<" | "=" | `<${string}` | `=${string}`
+                    : Bindings[K] extends (...args: any[]) => any
+                        ? "&" | `&${string}`
+                        : "<" | "=" | `<${string}` | `=${string}`;
+};
+
+export type FirebotComponent<Bindings, ExtraControllerProps = {}> = angular.IComponentOptions & {
+    bindings: BindingsDefinition<Bindings>;
+    controller: (
+        this: angular.IController & Bindings & ExtraControllerProps & { [key: string]: unknown },
+        ...args: unknown[]
+    ) => void;
+};

package/types/ui/backend-communicator.d.ts

@@ -0,0 +1,8 @@
+export type BackendCommunicator = {
+    on: (eventName: string, callback: (data: unknown) => void, async?: boolean) => string;
+    onAsync: (eventName: string, callback: (data: unknown) => Promise<unknown>) => string;
+    fireEventAsync: <T = unknown>(type: string, data?: unknown) => Promise<T>;
+    fireEventSync: <T = unknown>(type: string, data?: unknown) => T;
+    fireEvent: (type: string, data?: unknown) => void;
+    send: (type: string, data?: unknown) => void;
+};

package/types/ui/effect-helper-service.d.ts

@@ -0,0 +1,5 @@
+import type { EffectType } from "../effects";
+
+export type EffectHelperService = {
+    getAllEffectTypes: () => Promise<EffectType[]>;
+};

package/types/ui/effect-queues-service.d.ts

@@ -0,0 +1,10 @@
+import type { EffectQueueConfig } from "../../types";
+
+export type EffectQueuesService = {
+    effectQueues: EffectQueueConfig[];
+    getEffectQueues: () => EffectQueueConfig[];
+    getEffectQueue: (id: string) => EffectQueueConfig | undefined;
+    showAddEditEffectQueueModal: (queueId?: string) => Promise<string>;
+    showDeleteEffectQueueModal: (queueId: string) => Promise<boolean>;
+    queueModes: { value: string, label: string, description: string, iconClass: string }[];
+};

package/types/ui/firebot-root-scope.d.ts

@@ -0,0 +1,5 @@
+import type angular from "angular";
+
+export type FirebotRootScope = angular.IRootScopeService & {
+    copyTextToClipboard: (text: string) => void;
+};

package/types/ui/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./angular";
+export * from "./platform-service";
+export * from "./backend-communicator";
+export * from "./effect-helper-service";
+export * from "./settings-service";
+export * from "./modal-service";
+export * from "./modal-factory";
+export * from "./ng-toast";
+export * from "./firebot-root-scope";
+export * from "./object-copy-helper";
+export * from "./preset-effect-lists-service";
+export * from "./effect-queues-service";

package/types/ui/modal-factory.d.ts

@@ -0,0 +1,30 @@
+import type { EffectInstance } from "../effects";
+import type { TriggerType } from "../triggers";
+
+export type ModalFactory = {
+    showEditEffectModal: (
+        effectInstance: EffectInstance,
+        effectIndex: number | null,
+        trigger: TriggerType,
+        closeCallback: (response: {
+            action: "add" | "update" | "delete";
+            effect: EffectInstance | null;
+            index: number;
+        }) => void,
+        triggerMeta: unknown,
+        isNewEffect: boolean
+    ) => void;
+    openGetInputModal: <T extends string | number>(options: {
+        model: T;
+        inputType?: "text" | "number" | "password";
+        label: string;
+        inputPlaceholder?: string;
+        saveText?: string;
+        useTextArea?: boolean;
+        descriptionText?: string;
+        validationFn?: (input: T) => Promise<boolean>;
+        validationText?: string;
+        trigger?: TriggerType;
+        triggerMeta?: unknown;
+    }, callback: (result: T) => void, dismissCallback?: () => void) => void;
+};

package/types/ui/modal-service.d.ts

@@ -0,0 +1,21 @@
+import type angular from "angular";
+
+export type ModalService = {
+    showModal: (options: {
+        component?: string;
+        resolveObj?: { [key: string]: unknown };
+        dismissCallback?: () => void;
+        closeCallback?: (data: unknown) => void;
+        size?: "sm" | "md" | "mdlg" | "lg" | "xl";
+        keyboard?: boolean;
+        backdrop?: boolean | "static";
+        controllerFunc?: angular.Injectable<angular.IControllerConstructor>;
+        templateUrl?: string;
+        windowClass?: string;
+        breadcrumbName?: string;
+        /**
+         * @default true
+         */
+        autoSlide?: boolean;
+    }) => void;
+};

package/types/ui/ng-toast.d.ts

@@ -0,0 +1,3 @@
+export type NgToast = {
+    create: (options: { content: string, timeout?: number, className?: string } | string) => void;
+};

package/types/ui/object-copy-helper.d.ts

@@ -0,0 +1,9 @@
+import type { EffectInstance } from "../effects";
+import type { TriggerType } from "../triggers";
+
+export type ObjectCopyHelper = {
+    copyEffects: (effects: EffectInstance[]) => void;
+    getCopiedEffects: (trigger: TriggerType, triggerMeta: unknown) => Promise<EffectInstance[]>;
+    hasCopiedEffects: () => boolean;
+    cloneEffect: (effect: EffectInstance) => EffectInstance;
+};

package/types/ui/platform-service.d.ts

@@ -0,0 +1,7 @@
+export type PlatformService = {
+    platform: NodeJS.Platform;
+    isMacOs: boolean;
+    isWindows: boolean;
+    isLinux: boolean;
+    loadPlatform: () => void;
+};

package/types/ui/preset-effect-lists-service.d.ts

@@ -0,0 +1,20 @@
+import type { PresetEffectList } from "../effects";
+
+export type PresetEffectListsService = {
+    presetEffectLists: PresetEffectList[];
+    loadPresetEffectLists: () => void;
+    getPresetEffectLists: () => PresetEffectList[];
+    getPresetEffectList: (presetEffectListId: string) => PresetEffectList | undefined;
+    savePresetEffectList: (presetEffectList: PresetEffectList, isNew?: boolean) => PresetEffectList | null;
+    saveAllPresetEffectLists: (presetEffectLists: PresetEffectList[]) => void;
+    presetEffectListNameExists: (name: string) => boolean;
+    showRunPresetListModal: (id: string, isQuickAction?: boolean) => void;
+    manuallyTriggerPresetEffectList: (
+        presetEffectListId: string,
+        args?: Record<string, unknown>,
+        isQuickAction?: boolean
+    ) => void;
+    duplicatePresetEffectList: (presetEffectListId: string) => void;
+    deletePresetEffectList: (presetEffectListId: string) => void;
+    showAddEditPresetEffectListModal: (presetEffectList?: Partial<PresetEffectList>) => Promise<PresetEffectList | null>;
+};

package/types/ui/settings-service.d.ts

@@ -0,0 +1,5 @@
+import type { FirebotSettingsTypes } from "../settings";
+
+export type SettingsService = {
+    getSetting: <Key extends keyof FirebotSettingsTypes>(key: Key) => FirebotSettingsTypes[Key];
+};