@crowbartools/firebot-types 5.67.0-alpha11 → 5.67.0-alpha13

package/types/events.d.ts

@@ -1,26 +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"
-    | "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 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;
@@ -35,34 +15,28 @@ export type EventDefinition = {
         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;
@@ -73,17 +47,12 @@ export type EventFilter = {
     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;
@@ -93,17 +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

@@ -1,23 +1,11 @@
 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 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`).
@@ -28,4 +16,4 @@ export interface CustomHttpRoute {
 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

@@ -41,4 +41,4 @@ export * from "./variable-macros";
 export * from "./variables";
 export * from "./viewers";
 export * from "./webhooks";
-export * from "./websocket";
+export * from "./websocket";

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 {};

package/types/moderation.d.ts

@@ -2,38 +2,31 @@ 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;
@@ -56,4 +49,4 @@ export type ChatModerationSettings = {
         outputMessage?: string;
     };
     exemptRoles: string[];
-};
+};

package/types/modules/event-manager.d.ts

@@ -1,18 +1,15 @@
 import type { EventSource } from "../events";
-
 export type EventManagerModule = {
     /**
      * Registers an event source in Firebot.
      * @param eventSource The {@linkcode EventSource} you want to register.
      */
     registerEventSource: (eventSource: EventSource) => void;
-
     /**
      * Unregisters an event source from Firebot.
      * @param eventSourceId The ID of the event source to unregister.
      */
     unregisterEventSource: (eventSourceId: string) => void;
-
     /**
      * Triggers an event in Firebot.
      * @param eventSourceId The ID of the event source.
@@ -20,10 +17,5 @@ export type EventManagerModule = {
      * @param meta Any metadata you want to include with the event.
      * @param isManual `true` if the event is being triggered manually, `false` otherwise.
      */
-    triggerEvent: (
-        eventSourceId: string,
-        eventId: string,
-        meta: Record<string, unknown>,
-        isManual?: boolean
-    ) => void;
-};
+    triggerEvent: (eventSourceId: string, eventId: string, meta: Record<string, unknown>, isManual?: boolean) => void;
+};

package/types/modules/frontend-communicator.d.ts

@@ -4,11 +4,7 @@ export interface FrontendCommunicatorModule {
      * @param eventName The name of the event to send.
      * @param data Data to provide to the event handler.
      */
-    send<ExpectedArg = unknown>(
-        eventName: string,
-        data?: ExpectedArg
-    ): void;
-
+    send<ExpectedArg = unknown>(eventName: string, data?: ExpectedArg): void;
     /** Handle a synchronous event triggered by the frontend.
      * @template ExpectedArgs The type of data provided with the event.
      * @template ReturnPayload The type of data returned from the event handler.
@@ -16,11 +12,7 @@ export interface FrontendCommunicatorModule {
      * @param callback A function to handle the event.
      * @returns Unique ID of the registered event handler.
      */
-    on<ExpectedArgs extends Array<unknown> = [], ReturnPayload = void>(
-        eventName: string,
-        callback: (...args: ExpectedArgs) => ReturnPayload
-    ): void;
-
+    on<ExpectedArgs extends Array<unknown> = [], ReturnPayload = void>(eventName: string, callback: (...args: ExpectedArgs) => ReturnPayload): void;
     /** Handle an asynchronous event triggered by the frontend.
      * @template ExpectedArgs The type of data provided with the event.
      * @template ReturnPayload The type of data returned from the event handler.
@@ -28,26 +20,18 @@ export interface FrontendCommunicatorModule {
      * @param callback A function to asynchronously handle the event.
      * @returns Unique ID of the registered event handler.
      */
-    onAsync<ExpectedArgs extends Array<unknown> = [], ReturnPayload = void>(
-        eventName: string,
-        callback: (...args: ExpectedArgs) => Promise<ReturnPayload>
-    ): void;
-
+    onAsync<ExpectedArgs extends Array<unknown> = [], ReturnPayload = void>(eventName: string, callback: (...args: ExpectedArgs) => Promise<ReturnPayload>): void;
     /** Send an asynchronous event to the frontend that is capable of returning a result.
      * @template ReturnPayload The type of data returned from the event handler.
      * @template ExpectedArg The type of data provided with the event.
      * @param eventName The name of the event to send.
      * @param data The data to provide with the event.
      */
-    fireEventAsync<ReturnPayload = void, ExpectedArg = unknown>(
-        eventName: string,
-        data?: ExpectedArg
-    ): Promise<ReturnPayload>;
-
+    fireEventAsync<ReturnPayload = void, ExpectedArg = unknown>(eventName: string, data?: ExpectedArg): Promise<ReturnPayload>;
     /**
      * Unregisters a previously registered frontend event handler.
      * @param eventName The name of the event.
      * @param id The unique ID of the event handler to unregister. This ID is returned when you create an event handler using {@linkcode FrontendCommunicator.on | on} or {@linkcode FrontendCommunicator.onAsync | onAsync}.
      */
     off(eventName: string, id: string): void;
-}
+}

package/types/modules/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./event-manager";
-export * from "./frontend-communicator";
+export * from "./frontend-communicator";

package/types/notifications.d.ts

@@ -1,14 +1,11 @@
 export type NotificationSource = "external" | "internal" | "script";
-
 export type NotificationType = "info" | "tip" | "update" | "alert";
-
 export type ExternalNotification = {
     id: string;
     title: string;
     message: string;
     type: NotificationType;
 };
-
 export type NotificationBase = {
     title: string;
     message: string;
@@ -18,16 +15,14 @@ export type NotificationBase = {
     externalId?: string;
     metadata?: Record<string, unknown>;
 };
-
 export type Notification = NotificationBase & {
     id: string;
     timestamp: Date;
     saved: boolean;
     read: boolean;
 };
-
 export interface NotificationCache {
     dbVersion?: string;
     notifications: Notification[];
     knownExternalIds: string[];
-}
+}