@crowbartools/firebot-types 5.67.0-alpha1

package/types/effects.d.ts

@@ -0,0 +1,223 @@
+import ng from "angular";
+import type { TriggerType, TriggersObject, Trigger } from "./triggers";
+import type { Awaitable } from "./util-types";
+
+type Func<T> = (...args: unknown[]) => T;
+
+interface EffectScope<EffectModel> extends ng.IScope {
+    effect: EffectModel;
+    [x: string]: any;
+}
+
+export type EffectCategory =
+    | "common"
+    | "twitch"
+    | "moderation"
+    | "chat based"
+    | "dashboard"
+    | "overlay"
+    | "fun"
+    | "integrations"
+    | "firebot control"
+    | "advanced"
+    | "scripting";
+
+export type EffectTriggerResponse = {
+    success: boolean;
+    execution?: {
+        stop: boolean;
+        bubbleStop: boolean;
+    };
+    outputs?: {
+        [x: string]: unknown;
+    };
+};
+
+export type EffectOutput = {
+    label: string;
+    description: string;
+    defaultName: string;
+};
+
+export type EffectDependencies = {
+    twitch?: boolean;
+    integrations?: Record<string, boolean>;
+};
+
+export type OverlayExtension<OverlayData = unknown> = {
+    dependencies?: {
+        globalStyles?: string;
+        css?: string[];
+        js?: Array<string | { module: boolean, url: string }>;
+    };
+    event: {
+        name: string;
+        onOverlayEvent: (data: OverlayData) => void;
+    };
+};
+
+export type OverlayDimensions = {
+    width: number;
+    height: number;
+};
+
+export type OverlayPosition = {
+    position: string;
+    customCoords?: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    zIndex?: number;
+};
+
+export type OverlayRotation = {
+    rotation: number;
+    rotType: "deg" | "rad" | "turn";
+};
+
+export type OverlayEnterExitAnimations = {
+    enterAnimation: string;
+    enterDuration: number;
+
+    inbetweenAnimation: string;
+    inbetweenDuration: number;
+    inbetweenDelay: number;
+    inbetweenRepeat: number;
+
+    exitAnimation: string;
+    exitDuration: number;
+};
+
+export type OverlayInstance = {
+    overlayInstance: string;
+};
+
+export type EffectDefinition<EffectModel = unknown> = {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+    categories: EffectCategory[];
+    hidden?: boolean | Func<boolean>;
+    deprecated?: boolean;
+    triggers?: TriggerType[] | TriggersObject;
+    dependencies?: EffectDependencies | Array<"chat">;
+    showWhenDependenciesNotMet?: boolean;
+    outputs?: EffectOutput[];
+    /**
+         * If true, this effect cannot be aborted via the "Timeout" feature
+         */
+    exemptFromTimeouts?: boolean;
+    /**
+     * If true, this effect type cannot be set as "async" in the UI
+     */
+    exemptFromAsync?: boolean;
+    /**
+         * Keys of the effect model that should be exempt from having variables replaced in them automatically.
+         * This is useful when you want to run variable replacement manually, or not at all.
+         */
+    keysExemptFromAutoVariableReplacement?: Array<keyof EffectModel>;
+    /**
+     * If true, this effect does nothing when triggered (ex Comment effect)
+     * No-op effects are ignored by the random and sequential effects
+     */
+    isNoOp?: boolean;
+};
+
+export type EffectInstance<EffectModel = unknown> = {
+    id: string;
+    type: string;
+    effectLabel?: string | null;
+    effectComment?: string | null;
+    active?: boolean;
+    abortTimeout?: number | null;
+    percentWeight?: number | null;
+    outputNames?: Record<string, string>;
+    async?: boolean;
+} & {
+    [K in keyof EffectModel]: EffectModel[K];
+} & {
+    [x: string]: unknown;
+};
+
+export type EffectType<EffectModel = unknown, OverlayData = unknown> = {
+    definition: EffectDefinition<EffectModel>;
+    optionsTemplate: string;
+    optionsTemplateUrl?: string;
+    optionsController?: ($scope: EffectScope<EffectModel>, ...args: any[]) => void;
+    optionsValidator?: (effect: EffectModel, $scope: EffectScope<EffectModel>) => string[];
+    getDefaultLabel?: (effect: EffectModel, ...args: any[]) => Awaitable<string | undefined>;
+    onTriggerEvent: (event: {
+        effect: EffectInstance<EffectModel>;
+        trigger: Trigger;
+        sendDataToOverlay: (data: OverlayData, overlayInstance?: string) => void;
+        outputs: Record<string, unknown>;
+        abortSignal: AbortSignal;
+    }) => Awaitable<void | boolean | EffectTriggerResponse>;
+    overlayExtension?: OverlayExtension<OverlayData>;
+};
+
+export type EffectListRunMode = "all" | "random" | "sequential";
+
+export interface EffectList {
+    id: string;
+    list: EffectInstance[];
+    queue?: string | null;
+    queuePriority?: "high" | "none";
+    queueDuration?: number;
+    runMode?: EffectListRunMode;
+    weighted?: boolean;
+    dontRepeatUntilAllUsed?: boolean;
+}
+
+export type PresetEffectList = {
+    id: string;
+    name: string;
+    args: Array<{
+        name: string;
+    }>;
+    effects: EffectList;
+    sortTags: string[];
+};
+
+type QueueMode = "auto" | "interval" | "custom" | "manual";
+
+export type EffectQueueConfig = {
+    id: string;
+    name: string;
+    mode: QueueMode;
+    interval?: number;
+    sortTags: string[];
+    active: boolean;
+    runEffectsImmediatelyWhenPaused: boolean;
+    length: number;
+    queue: any[];
+};
+
+export type QueueStatus = "running" | "paused" | "idle" | "canceled";
+
+export type RunEffectsContext = {
+    trigger: Trigger;
+    effects: EffectList;
+    outputs?: {
+        [x: string]: unknown;
+    };
+    [key: string]: unknown;
+};
+
+type QueueItem = {
+    runEffectsContext: RunEffectsContext;
+    duration?: number;
+    priority?: "none" | "high";
+};
+
+export type QueueState = {
+    status: QueueStatus;
+    queuedItems: QueueItem[];
+    activeItems: QueueItem[];
+    interval: number;
+    mode: QueueMode;
+    runEffectsImmediatelyWhenPaused?: boolean;
+};

package/types/events.d.ts

@@ -0,0 +1,99 @@
+import type { EffectList } from "./effects";
+import type { Awaitable } from "./util-types";
+
+export type ComparisonType =
+    | "is"
+    | "is not"
+    | "greater than"
+    | "greater than or equal to"
+    | "less than"
+    | "less than or equal to"
+    | "contains"
+    | "doesn't contain"
+    | "doesn't start with"
+    | "starts with"
+    | "doesn't end with"
+    | "ends with"
+    | "matches regex"
+    | "doesn't matches regex"
+    | "matches regex (case insensitive)"
+    | "doesn't match regex (case insensitive)";
+
+export type EventDefinition = {
+    id: string;
+    name: string;
+    description: string;
+    cached?: boolean;
+    cacheMetaKey?: string;
+    cacheTtlInSecs?: number;
+    manualMetadata?: Record<string, unknown>;
+    activityFeed?: {
+        icon: string;
+        getMessage: (eventData: Record<string, any>) => string;
+        excludeFromChatFeed?: boolean;
+    };
+};
+
+export type EventSource = {
+    id: string;
+    name: string;
+    description?: string;
+    events: EventDefinition[];
+};
+
+export type PresetValue = {
+    value: any;
+    display: string;
+};
+
+export type FilterSettings = {
+    type: string;
+    comparisonType: ComparisonType;
+    value: any;
+};
+
+export type EventSourceAndId = {
+    eventSourceId: string;
+    eventId: string;
+};
+
+export type EventData = EventSourceAndId & {
+    eventMeta: Record<string, any>;
+};
+
+export type EventFilter = {
+    id: string;
+    name: string;
+    description: string;
+    events: EventSourceAndId[];
+    comparisonTypes: string[];
+    valueType: "text" | "preset";
+    presetValues?(...args: unknown[]): Awaitable<PresetValue[]>;
+    valueIsStillValid?(filterSettings: FilterSettings, ...args: unknown[]): Awaitable<boolean>;
+    getSelectedValueDisplay?(filterSettings: FilterSettings, ...args: unknown[]): Awaitable<string>;
+    predicate(
+        filterSettings: FilterSettings,
+        eventData: EventData
+    ): Awaitable<boolean>;
+};
+
+export type EventFilterData = {
+    mode: "inclusive" | "exclusive";
+    filters: FilterSettings[];
+};
+
+export type EventSettings = {
+    id: string;
+    type: string;
+    active: boolean;
+    effectLabel?: string;
+    filterData?: EventFilterData;
+    effects: EffectList;
+    [x: string]: unknown;
+};
+
+export type EventGroup = {
+    id: string;
+    events: EventSettings[];
+    active?: boolean;
+};

package/types/expressionish.d.ts

@@ -0,0 +1,74 @@
+type ExpressionishBaseToken = {
+    type: "TEXT" | "VARIABLE" | "LOOKUP" | "IF" | "LOGICAL" | "CONDITION" | "UNKNOWN";
+
+    /**
+     * Rough character position of the token within the input string
+     */
+    position: number;
+
+    /**
+     * Depends on token type.
+     *
+     * `TEXT` or `UNKNOWN`: raw text value
+     *
+     * `VAR`, `IF`, or `LOOKUP`: name of variable
+     *
+     * `CONDITION` or `LOGICAL`: operator
+     */
+    value: string;
+
+};
+
+type ExpressionishTokenWithArguments = {
+    /**
+     * Arguments to resolve then pass to calling registered handler
+     */
+    arguments: Array<ExpressionishToken>;
+};
+
+type ExpressionishTextToken = ExpressionishBaseToken & {
+    type: "TEXT";
+};
+
+type ExpressionishLookupToken = ExpressionishBaseToken & ExpressionishTokenWithArguments & {
+    type: "LOOKUP";
+
+    /**
+     * Lookup prefix
+     */
+    prefix: string;
+};
+
+type ExpressionishVariableToken = ExpressionishBaseToken & ExpressionishTokenWithArguments & {
+    type: "VARIABLE";
+};
+
+type ExpressionishComparisonToken = ExpressionishBaseToken & ExpressionishTokenWithArguments & {
+    type: "CONDITION";
+};
+
+type ExpressionishLogicToken = ExpressionishBaseToken & ExpressionishTokenWithArguments & {
+    type: "LOGICAL";
+};
+
+type ExpressionishIfToken = ExpressionishBaseToken & ExpressionishTokenWithArguments & {
+    type: "IF";
+
+    /**
+     * Condition used for evaluation
+     */
+    condition: ExpressionishLogicToken | ExpressionishComparisonToken;
+};
+
+type ExpressionishUnknownToken = ExpressionishBaseToken & {
+    type: "UNKNOWN";
+};
+
+export type ExpressionishToken =
+    | ExpressionishTextToken
+    | ExpressionishLookupToken
+    | ExpressionishVariableToken
+    | ExpressionishComparisonToken
+    | ExpressionishLogicToken
+    | ExpressionishIfToken
+    | ExpressionishUnknownToken;

package/types/games.d.ts

@@ -0,0 +1,22 @@
+import type { FirebotParamCategory } from "./parameters";
+
+export type GameSettings = {
+    active: boolean;
+    settings?: Record<string, Record<string, unknown>>;
+};
+
+export type GameDefinition = {
+    id: string;
+    name: string;
+    subtitle: string;
+    description: string;
+    icon: string;
+    active?: boolean;
+    settingCategories: Record<string, FirebotParamCategory<Record<string, unknown>>>;
+};
+
+export type FirebotGame = GameDefinition & {
+    onLoad: (settings: GameSettings) => void;
+    onUnload: (settings: GameSettings) => void;
+    onSettingsUpdate: (settings: GameSettings) => void;
+};

package/types/goals.d.ts

@@ -0,0 +1,7 @@
+export declare enum TwitchGoalTypes {
+    follow = "follower",
+    sub = "subscription_count",
+    subpoint = "subscription",
+    newsub = "new_subscription_count",
+    newsubpoint = "new_subscription"
+}

package/types/hotkeys.d.ts

@@ -0,0 +1,12 @@
+import type { EffectList } from "./effects";
+
+export type FirebotHotkey = {
+    id: string;
+    name: string;
+    active: boolean;
+    // Electron accelerator string (see https://www.electronjs.org/docs/latest/api/accelerator)
+    code: string;
+    warning: string;
+    effects: EffectList;
+    sortTags: string[];
+};

package/types/icons.d.ts

@@ -0,0 +1,6 @@
+export type FontAwesomeIcon = {
+    name: string;
+    className: string;
+    style: string;
+    searchTerms: string[];
+};

package/types/import.d.ts

@@ -0,0 +1,69 @@
+import type { Quote } from "./quotes";
+import type { FileFilter, Awaitable } from "./util-types";
+
+export interface LoadRequest {
+    appId: string;
+    filepath: string;
+}
+
+export interface LoadResult<T = unknown[]> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+
+export type ParsedQuotes = {
+    quotes: Quote[];
+};
+
+export type ParsedViewers<V = unknown> = {
+    viewers: V[];
+    ranks: string[];
+};
+
+export interface ImportRequest<Data = unknown, Settings = unknown> {
+    appId: string;
+    data: Data;
+    settings: Settings;
+}
+
+export interface ImportResult {
+    success: boolean;
+    error?: string;
+}
+
+type CustomImporterSettings = {
+    quotes?: unknown;
+    viewers?: unknown;
+};
+
+export type ThirdPartyImporter<
+    Settings extends CustomImporterSettings = CustomImporterSettings,
+    ViewerType = unknown
+> = {
+    id: string;
+    appName: string;
+    defaultSettings?: Settings;
+    filetypes: FileFilter[];
+
+    loadQuotes?: (
+        filename: string,
+        settings?: Settings["quotes"]
+    ) => Awaitable<LoadResult<ParsedQuotes>>;
+
+    importQuotes?: (
+        quotes: Quote[],
+        settings: Settings["quotes"]
+    ) => Awaitable<ImportResult>;
+
+    loadViewers?: (
+        filename: string,
+        settings?: Settings["viewers"]
+    ) => Awaitable<LoadResult<ParsedViewers>>;
+
+    importViewers?: (
+        viewers: ViewerType[],
+        settings: Settings["viewers"],
+        abortSignal: AbortSignal
+    ) => Awaitable<ImportResult>;
+};

package/types/index.d.ts

@@ -0,0 +1,40 @@
+export * from "./accounts";
+export * from "./auth";
+export * from "./channel-rewards";
+export * from "./chat";
+export * from "./commands";
+export * from "./counters";
+export * from "./currency";
+export * from "./discord";
+export * from "./effects";
+export * from "./events";
+export * from "./expressionish";
+export * from "./games";
+export * from "./goals";
+export * from "./hotkeys";
+export * from "./icons";
+export * from "./import";
+export * from "./integrations";
+export * from "./moderation";
+export * from "./modules";
+export * from "./overlay-widgets";
+export * from "./parameters";
+export * from "./pronouns";
+export * from "./quick-actions";
+export * from "./quotes";
+export * from "./ranks";
+export * from "./restrictions";
+export * from "./roles";
+export * from "./settings";
+export * from "./setups";
+export * from "./sort-tags";
+export * from "./timers";
+export * from "./triggers";
+export * from "./ui";
+export * from "./util-types";
+export * from "./variable-macros";
+export * from "./variables";
+export * from "./viewers";
+export * from "./webhooks";
+export * from "./websocket";
+export * from "./plugins";

package/types/integrations.d.ts

@@ -0,0 +1,93 @@
+import type {
+    FirebotParameterCategories,
+    FirebotParams
+} from "./parameters";
+import type { Awaitable, ObjectOfUnknowns } from "./util-types";
+
+export type Integration<Params extends FirebotParams = FirebotParams> = {
+    definition: IntegrationDefinition<Params>;
+    integration: IntegrationController<Params>;
+};
+
+export type IntegrationDefinition<
+    Params extends FirebotParams = FirebotParams
+> = {
+    id: string;
+    name: string;
+    description: string;
+    connectionToggle?: boolean;
+    configurable?: boolean;
+    settingCategories: FirebotParameterCategories<Params>;
+} & (
+    | {
+        linkType: "id";
+        idDetails: {
+            steps: string;
+        };
+    }
+    | {
+        linkType: "auth";
+        authProviderDetails: {
+            id: string;
+            name: string;
+            redirectUriHost?: string;
+            client: {
+                id: string;
+                secret: string;
+            };
+            auth: {
+                tokenHost: string;
+                tokenPath: string;
+                authorizePath: string;
+            };
+            autoRefreshToken?: boolean;
+            scopes: string;
+        };
+    }
+    | { linkType: "other" | "none" }
+);
+
+export interface IntegrationEvents {
+    connected: (id: string) => void;
+    disconnected: (id: string) => void;
+    "settings-update": (id: string, settings: Record<string, any>) => void;
+}
+
+type LinkData =
+    | {
+        accountId: string;
+    }
+    | {
+        auth: Record<string, unknown>;
+    }
+    | null;
+
+export type IntegrationData<Params extends FirebotParams = FirebotParams> = {
+    settings: any;
+    userSettings?: Params;
+    oauth?: any;
+    accountId?: string;
+};
+
+export interface IntegrationController<
+    Params extends FirebotParams = FirebotParams
+> {
+    connected: boolean;
+    init(
+        linked: boolean,
+        integrationData: IntegrationData<Params>
+    ): Awaitable<void>;
+    link?(linkData: LinkData): Awaitable<void>;
+    connect?(
+        integrationData: IntegrationData<Params>
+    ): Awaitable<void>;
+    disconnect?(): Awaitable<void>;
+    onUserSettingsUpdate?(
+        integrationData: IntegrationData<Params>
+    ): Awaitable<void>;
+}
+
+type IntegrationWithUnknowns = {
+    definition: IntegrationDefinition & ObjectOfUnknowns;
+    integration: IntegrationController & ObjectOfUnknowns;
+};

package/types/moderation.d.ts

@@ -0,0 +1,59 @@
+export type ModerationTerm = {
+    text: string;
+    createdAt: number;
+};
+
+export type ModerationUser = {
+    id: string;
+    username: string;
+    displayName: string;
+};
+
+export type AllowedUser = {
+    id: string;
+    username: string;
+    displayName: string;
+    createdAt: number;
+};
+
+export type BannedWords = {
+    words: ModerationTerm[];
+};
+
+export type BannedRegularExpressions = {
+    regularExpressions: ModerationTerm[];
+};
+
+export type AllowList = {
+    urls: ModerationTerm[];
+    users: AllowedUser[];
+};
+
+export type ModerationImportRequest = {
+    filePath: string;
+    delimiter: "newline" | "comma" | "space";
+};
+
+export type ChatModerationSettings = {
+    bannedWordList: {
+        enabled: boolean;
+        exemptRoles: string[];
+        outputMessage?: string;
+    };
+    emoteLimit: {
+        enabled: boolean;
+        exemptRoles: string[];
+        max: number;
+        outputMessage?: string;
+    };
+    urlModeration: {
+        enabled: boolean;
+        exemptRoles: string[];
+        viewTime: {
+            enabled: boolean;
+            viewTimeInHours: number;
+        };
+        outputMessage?: string;
+    };
+    exemptRoles: string[];
+};