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

package/types/effects.d.ts

@@ -1,27 +1,13 @@
 import ng from "angular";
 import type { TriggerType, TriggersObject, Trigger } from "./triggers";
 import type { Awaitable } from "./util-types";
-
+import { EventSourceAndId } from "./events";
 type Func<T> = (...args: unknown[]) => T;
-
-interface EffectScope<EffectModel> extends ng.IScope {
+export 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 EffectCategory = "common" | "twitch" | "moderation" | "chat based" | "dashboard" | "overlay" | "fun" | "integrations" | "firebot control" | "advanced" | "scripting";
 export type EffectTriggerResponse = {
     success: boolean;
     execution?: {
@@ -32,35 +18,33 @@ export type EffectTriggerResponse = {
         [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 }>;
+        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?: {
@@ -71,29 +55,23 @@ export type OverlayPosition = {
     };
     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;
@@ -125,7 +103,6 @@ export type EffectDefinition<EffectModel = unknown> = {
      */
     isNoOp?: boolean;
 };
-
 export type EffectInstance<EffectModel = unknown> = {
     id: string;
     type: string;
@@ -141,7 +118,6 @@ export type EffectInstance<EffectModel = unknown> = {
 } & {
     [x: string]: unknown;
 };
-
 export type EffectType<EffectModel = unknown, OverlayData = unknown> = {
     definition: EffectDefinition<EffectModel>;
     optionsTemplate: string;
@@ -158,9 +134,7 @@ export type EffectType<EffectModel = unknown, OverlayData = unknown> = {
     }) => Awaitable<void | boolean | EffectTriggerResponse>;
     overlayExtension?: OverlayExtension<OverlayData>;
 };
-
 export type EffectListRunMode = "all" | "random" | "sequential";
-
 export interface EffectList {
     id: string;
     list: EffectInstance[];
@@ -171,7 +145,6 @@ export interface EffectList {
     weighted?: boolean;
     dontRepeatUntilAllUsed?: boolean;
 }
-
 export type PresetEffectList = {
     id: string;
     name: string;
@@ -181,9 +154,7 @@ export type PresetEffectList = {
     effects: EffectList;
     sortTags: string[];
 };
-
 type QueueMode = "auto" | "interval" | "custom" | "manual";
-
 export type EffectQueueConfig = {
     id: string;
     name: string;
@@ -195,9 +166,7 @@ export type EffectQueueConfig = {
     length: number;
     queue: any[];
 };
-
 export type QueueStatus = "running" | "paused" | "idle" | "canceled";
-
 export type RunEffectsContext = {
     trigger: Trigger;
     effects: EffectList;
@@ -206,13 +175,11 @@ export type RunEffectsContext = {
     };
     [key: string]: unknown;
 };
-
-type QueueItem = {
+export type QueueItem = {
     runEffectsContext: RunEffectsContext;
     duration?: number;
     priority?: "none" | "high";
 };
-
 export type QueueState = {
     status: QueueStatus;
     queuedItems: QueueItem[];
@@ -220,4 +187,14 @@ export type QueueState = {
     interval: number;
     mode: QueueMode;
     runEffectsImmediatelyWhenPaused?: boolean;
-};
+};
+export type AdditionalEffectEvent = {
+    effectId: string;
+    eventSourceId: string;
+    eventId: string;
+};
+export type PluginAdditionalEffectEvents = {
+    effectId: string;
+    events: EventSourceAndId[];
+};
+export {};

package/types/events.d.ts

@@ -1,24 +1,6 @@
 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 ComparisonType = "is" | "is not" | "greater than" | "greater than or equal to" | "less than" | "less than or equal to" | "include" | "doesn't include" | "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;
@@ -33,55 +15,44 @@ export type EventDefinition = {
         excludeFromChatFeed?: boolean;
     };
 };
-
 export type EventSource = {
     id: string;
     name: string;
     description?: string;
     events: EventDefinition[];
 };
-
 export type PresetValue = {
-    value: any;
+    value: unknown;
     display: string;
 };
-
 export type FilterSettings = {
     type: string;
     comparisonType: ComparisonType;
-    value: any;
+    value: unknown;
 };
-
 export type EventSourceAndId = {
     eventSourceId: string;
     eventId: string;
 };
-
 export type EventData = EventSourceAndId & {
-    eventMeta: Record<string, any>;
+    eventMeta: Record<string, unknown>;
 };
-
 export type EventFilter = {
     id: string;
     name: string;
     description: string;
     events: EventSourceAndId[];
     comparisonTypes: string[];
-    valueType: "text" | "preset";
+    valueType: "text" | "number" | "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>;
+    predicate(filterSettings: FilterSettings, eventData: EventData): Awaitable<boolean>;
 };
-
 export type EventFilterData = {
     mode: "inclusive" | "exclusive";
     filters: FilterSettings[];
 };
-
 export type EventSettings = {
     id: string;
     type: string;
@@ -91,9 +62,15 @@ export type EventSettings = {
     effects: EffectList;
     [x: string]: unknown;
 };
-
 export type EventGroup = {
     id: string;
     events: EventSettings[];
     active?: boolean;
-};
+};
+export type TriggeredEvent = {
+    event: EventDefinition;
+    source: EventSource;
+    meta: Record<string, unknown>;
+    isManual: boolean;
+    isRetrigger: boolean;
+};

package/types/expressionish.d.ts

@@ -1,11 +1,9 @@
 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.
      *
@@ -16,59 +14,41 @@ type ExpressionishBaseToken = {
      * `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;
+export type ExpressionishToken = ExpressionishTextToken | ExpressionishLookupToken | ExpressionishVariableToken | ExpressionishComparisonToken | ExpressionishLogicToken | ExpressionishIfToken | ExpressionishUnknownToken;
+export {};

package/types/games.d.ts

@@ -1,10 +1,8 @@
 import type { FirebotParamCategory } from "./parameters";
-
 export type GameSettings = {
     active: boolean;
     settings?: Record<string, Record<string, unknown>>;
 };
-
 export type GameDefinition = {
     id: string;
     name: string;
@@ -14,9 +12,8 @@ export type GameDefinition = {
     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/hotkeys.d.ts

@@ -1,12 +1,10 @@
 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/http-server.d.ts

@@ -0,0 +1,19 @@
+import type { Request, Response } from "express";
+import type { Awaitable } from "./util-types";
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "CONNECT" | "OPTIONS" | "TRACE";
+export interface CustomHttpRoute {
+    path: string;
+    method: HttpMethod;
+    handler: (req: Request, res: Response) => Awaitable<void>;
+}
+/**
+ * Defines custom HTTP routes that plugins can add to the internal Firebot HTTP server.
+ * Paths can contain multiple levels and parameters (e.g. `/item/:id`).
+ * Full routes are built as follows (default Firebot hostname/port used as an example):
+ *
+ * `{method} http://localhost:7472/plugins/{prefix}/{path}`
+ */
+export interface PluginHttpRouteDefinition {
+    prefix: string;
+    routes: Array<CustomHttpRoute>;
+}

package/types/icons.d.ts

@@ -3,4 +3,4 @@ export type FontAwesomeIcon = {
     className: string;
     style: string;
     searchTerms: string[];
-};
+};

package/types/import.d.ts

@@ -1,69 +1,42 @@
 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
-> = {
+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>;
-};
+    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>;
+};
+export {};

package/types/index.d.ts

@@ -3,6 +3,7 @@ export * from "./auth";
 export * from "./channel-rewards";
 export * from "./chat";
 export * from "./commands";
+export * from "./control-deck";
 export * from "./counters";
 export * from "./currency";
 export * from "./discord";
@@ -12,13 +13,17 @@ export * from "./expressionish";
 export * from "./games";
 export * from "./goals";
 export * from "./hotkeys";
+export * from "./http-server";
 export * from "./icons";
 export * from "./import";
 export * from "./integrations";
 export * from "./moderation";
 export * from "./modules";
+export * from "./notifications";
 export * from "./overlay-widgets";
 export * from "./parameters";
+export * from "./plugins";
+export * from "./power-ups";
 export * from "./pronouns";
 export * from "./quick-actions";
 export * from "./quotes";
@@ -31,10 +36,10 @@ export * from "./sort-tags";
 export * from "./timers";
 export * from "./triggers";
 export * from "./ui";
+export * from "./ui-extensions";
 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

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