ogi-addon 1.9.3 → 1.9.4

package/build/EventResponse-D1c-Df5W.d.cts

@@ -0,0 +1,430 @@
+import { n as ConfigurationBuilder, r as ConfigurationFile } from "./ConfigurationBuilder-CfHLKMTO.cjs";
+import { t as Configuration } from "./Configuration-WeOm-F0_.cjs";
+import { t as SearchResult } from "./SearchEngine-DBSUNM4A.cjs";
+import events from "node:events";
+import { IFuseOptions } from "fuse.js";
+import { z } from "zod";
+
+//#region src/main.d.ts
+type OGIAddonEvent = 'connect' | 'disconnect' | 'configure' | 'authenticate' | 'search' | 'setup' | 'library-search' | 'game-details' | 'exit' | 'check-for-updates' | 'task-run' | 'request-dl' | 'catalog';
+type OGIAddonClientSentEvent = 'response' | 'authenticate' | 'configure' | 'defer-update' | 'notification' | 'input-asked' | 'get-app-details' | 'search-app-name' | 'flag' | 'task-update';
+type OGIAddonServerSentEvent = 'authenticate' | 'configure' | 'config-update' | 'search' | 'setup' | 'response' | 'library-search' | 'check-for-updates' | 'task-run' | 'game-details' | 'request-dl' | 'catalog';
+declare const VERSION: string;
+interface ClientSentEventTypes {
+  response: any;
+  authenticate: {
+    name: string;
+    id: string;
+    description: string;
+    version: string;
+    author: string;
+  };
+  configure: ConfigurationFile;
+  'defer-update': {
+    logs: string[];
+    progress: number;
+  };
+  notification: Notification;
+  'input-asked': ConfigurationBuilder;
+  'task-update': {
+    id: string;
+    progress: number;
+    logs: string[];
+    finished: boolean;
+    failed: string | undefined;
+  };
+  'get-app-details': {
+    appID: number;
+    storefront: string;
+  };
+  'search-app-name': {
+    query: string;
+    storefront: string;
+  };
+  flag: {
+    flag: string;
+    value: string | string[];
+  };
+}
+type BasicLibraryInfo = {
+  name: string;
+  capsuleImage: string;
+  appID: number;
+  storefront: string;
+};
+type SetupEventResponse = Omit<LibraryInfo, 'capsuleImage' | 'coverImage' | 'name' | 'appID' | 'storefront' | 'addonsource' | 'titleImage'> & {
+  redistributables?: {
+    name: string;
+    path: string;
+  }[];
+};
+interface EventListenerTypes {
+  /**
+   * This event is emitted when the addon connects to the OGI Addon Server. Addon does not need to resolve anything.
+   * @param event
+   * @returns
+   */
+  connect: (event: EventResponse<void>) => void;
+  /**
+   * This event is emitted when the client requests for the addon to disconnect. Addon does not need to resolve this event, but we recommend `process.exit(0)` so the addon can exit gracefully instead of by force by the addon server.
+   * @param reason
+   * @returns
+   */
+  disconnect: (reason: string) => void;
+  /**
+   * This event is emitted when the client requests for the addon to configure itself. Addon should resolve the event with the internal configuration. (See ConfigurationBuilder)
+   * @param config
+   * @returns
+   */
+  configure: (config: ConfigurationBuilder) => ConfigurationBuilder;
+  /**
+   * This event is called when the client provides a response to any event. This should be treated as middleware.
+   * @param response
+   * @returns
+   */
+  response: (response: any) => void;
+  /**
+   * This event is called when the client requests for the addon to authenticate itself. You don't need to provide any info.
+   * @param config
+   * @returns
+   */
+  authenticate: (config: any) => void;
+  /**
+   * This event is emitted when the client requests for a torrent/direct download search to be performed. Addon is given the gameID (could be a steam appID or custom store appID), along with the storefront type. Addon should resolve the event with the search results. (See SearchResult)
+   * @param query
+   * @param event
+   * @returns
+   */
+  search: (query: {
+    storefront: string;
+    appID: number;
+  } & ({
+    for: 'game' | 'task' | 'all';
+  } | {
+    for: 'update';
+    libraryInfo: LibraryInfo;
+  }), event: EventResponse<SearchResult[]>) => void;
+  /**
+   * This event is emitted when the client requests for app setup to be performed. Addon should resolve the event with the metadata for the library entry. (See LibraryInfo)
+   * @param data
+   * @param event
+   * @returns
+   */
+  setup: (data: {
+    path: string;
+    type: 'direct' | 'torrent' | 'magnet' | 'empty';
+    name: string;
+    usedRealDebrid: boolean;
+    multiPartFiles?: {
+      name: string;
+      downloadURL: string;
+    }[];
+    appID: number;
+    storefront: string;
+    manifest?: Record<string, unknown>;
+  } & ({
+    for: 'game';
+  } | {
+    for: 'update';
+    currentLibraryInfo: LibraryInfo;
+  }), event: EventResponse<SetupEventResponse>) => void;
+  /**
+   * This event is emitted when the client requires for a search to be performed. Input is the search query.
+   * @param query
+   * @param event
+   * @returns
+   */
+  'library-search': (query: string, event: EventResponse<BasicLibraryInfo[]>) => void;
+  /**
+   * This event is emitted when the client requests for a task to be run. Addon should resolve the event with the task.
+   * @param task
+   * @param event
+   * @returns
+   */
+  'task-run': (task: {
+    manifest: Record<string, unknown>;
+    downloadPath: string;
+    name: string;
+  }, event: EventResponse<void>) => void;
+  /**
+   * This event is emitted when the client requests for a game details to be fetched. Addon should resolve the event with the game details. This is used to generate a store page for the game.
+   * @param appID
+   * @param event
+   * @returns
+   */
+  'game-details': (details: {
+    appID: number;
+    storefront: string;
+  }, event: EventResponse<StoreData | undefined>) => void;
+  /**
+   * This event is emitted when the client requests for the addon to exit. Use this to perform any cleanup tasks, ending with a `process.exit(0)`.
+   * @returns
+   */
+  exit: () => void;
+  /**
+   * This event is emitted when the client requests for a download to be performed with the 'request' type. Addon should resolve the event with a SearchResult containing the actual download info.
+   * @param appID
+   * @param info
+   * @param event
+   * @returns
+   */
+  'request-dl': (appID: number, info: SearchResult, event: EventResponse<SearchResult>) => void;
+  /**
+   * This event is emitted when the client requests for a catalog to be fetched. Addon should resolve the event with the catalog.
+   * @param event
+   * @returns
+   */
+  catalog: (event: Omit<EventResponse<{
+    [key: string]: {
+      name: string;
+      description: string;
+      listings: BasicLibraryInfo[];
+    };
+  }>, 'askForInput'>) => void;
+  /**
+   * This event is emitted when the client requests for an addon to check for updates. Addon should resolve the event with the update information.
+   * @param data
+   * @param event
+   * @returns
+   */
+  'check-for-updates': (data: {
+    appID: number;
+    storefront: string;
+    currentVersion: string;
+  }, event: EventResponse<{
+    available: true;
+    version: string;
+  } | {
+    available: false;
+  }>) => void;
+}
+interface StoreData {
+  name: string;
+  publishers: string[];
+  developers: string[];
+  appID: number;
+  releaseDate: string;
+  capsuleImage: string;
+  coverImage: string;
+  basicDescription: string;
+  description: string;
+  headerImage: string;
+  latestVersion: string;
+}
+interface WebsocketMessageClient {
+  event: OGIAddonClientSentEvent;
+  id?: string;
+  args: any;
+  statusError?: string;
+}
+interface WebsocketMessageServer {
+  event: OGIAddonServerSentEvent;
+  id?: string;
+  args: any;
+  statusError?: string;
+}
+/**
+ * The configuration for the addon. This is used to identify the addon and provide information about it.
+ * Storefronts is an array of names of stores that the addon supports.
+ */
+interface OGIAddonConfiguration {
+  name: string;
+  id: string;
+  description: string;
+  version: string;
+  author: string;
+  repository: string;
+  storefronts: string[];
+}
+/**
+ * The main class for the OGI Addon. This class is used to interact with the OGI Addon Server. The OGI Addon Server provides a `--addonSecret` to the addon so it can securely connect.
+ * @example
+ * ```typescript
+ * const addon = new OGIAddon({
+ *  name: 'Test Addon',
+ *   id: 'test-addon',
+ *  description: 'A test addon',
+ *  version: '1.0.0',
+ *  author: 'OGI Developers',
+ *  repository: ''
+ * });
+ * ```
+ *
+ */
+declare class OGIAddon {
+  eventEmitter: events<[never]>;
+  addonWSListener: OGIAddonWSListener;
+  addonInfo: OGIAddonConfiguration;
+  config: Configuration;
+  private eventsAvailable;
+  private registeredConnectEvent;
+  constructor(addonInfo: OGIAddonConfiguration);
+  /**
+   * Register an event listener for the addon. (See EventListenerTypes)
+   * @param event {OGIAddonEvent}
+   * @param listener {EventListenerTypes[OGIAddonEvent]}
+   */
+  on<T extends OGIAddonEvent>(event: T, listener: EventListenerTypes[T]): void;
+  emit<T extends OGIAddonEvent>(event: T, ...args: Parameters<EventListenerTypes[T]>): void;
+  /**
+   * Notify the client using a notification. Provide the type of notification, the message, and an ID.
+   * @param notification {Notification}
+   */
+  notify(notification: Notification): void;
+  /**
+   * Get the app details for a given appID and storefront.
+   * @param appID {number}
+   * @param storefront {string}
+   * @returns {Promise<StoreData>}
+   */
+  getAppDetails(appID: number, storefront: string): Promise<StoreData | undefined>;
+  searchGame(query: string, storefront: string): Promise<BasicLibraryInfo[]>;
+  /**
+   * Notify the OGI Addon Server that you are performing a background task. This can be used to help users understand what is happening in the background.
+   * @param id {string}
+   * @param progress {number}
+   * @param logs {string[]}
+   */
+  task(): Promise<CustomTask>;
+  /**
+   * Extract a file using 7-Zip on Windows, unzip on Linux/Mac.
+   * @param path {string}
+   * @param outputPath {string}
+   * @param type {'unrar' | 'unzip'}
+   * @returns {Promise<void>}
+   */
+  extractFile(path: string, outputPath: string, type: 'unrar' | 'unzip'): Promise<void>;
+}
+declare class CustomTask {
+  readonly id: string;
+  progress: number;
+  logs: string[];
+  finished: boolean;
+  ws: OGIAddonWSListener;
+  failed: string | undefined;
+  constructor(ws: OGIAddonWSListener, id: string, progress: number, logs: string[]);
+  log(log: string): void;
+  finish(): void;
+  fail(message: string): void;
+  setProgress(progress: number): void;
+  update(): void;
+}
+/**
+ * A search tool wrapper over Fuse.js for the OGI Addon. This tool is used to search for items in the library.
+ * @example
+ * ```typescript
+ * const searchTool = new SearchTool<LibraryInfo>([{ name: 'test', appID: 123 }, { name: 'test2', appID: 124 }], ['name']);
+ * const results = searchTool.search('test', 10);
+ * ```
+ */
+declare class SearchTool<T> {
+  private fuse;
+  constructor(items: T[], keys: string[], options?: Omit<IFuseOptions<T>, 'keys'>);
+  search(query: string, limit?: number): T[];
+  addItems(items: T[]): void;
+}
+/**
+ * Library Info is the metadata for a library entry after setting up a game.
+ */
+declare const ZodLibraryInfo: z.ZodObject<{
+  name: z.ZodString;
+  version: z.ZodString;
+  cwd: z.ZodString;
+  appID: z.ZodNumber;
+  launchExecutable: z.ZodString;
+  launchArguments: z.ZodOptional<z.ZodString>;
+  capsuleImage: z.ZodString;
+  storefront: z.ZodString;
+  addonsource: z.ZodString;
+  coverImage: z.ZodString;
+  titleImage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+  name: string;
+  version: string;
+  cwd: string;
+  appID: number;
+  launchExecutable: string;
+  capsuleImage: string;
+  storefront: string;
+  addonsource: string;
+  coverImage: string;
+  launchArguments?: string | undefined;
+  titleImage?: string | undefined;
+}, {
+  name: string;
+  version: string;
+  cwd: string;
+  appID: number;
+  launchExecutable: string;
+  capsuleImage: string;
+  storefront: string;
+  addonsource: string;
+  coverImage: string;
+  launchArguments?: string | undefined;
+  titleImage?: string | undefined;
+}>;
+type LibraryInfo = z.infer<typeof ZodLibraryInfo>;
+interface Notification {
+  type: 'warning' | 'error' | 'info' | 'success';
+  message: string;
+  id: string;
+}
+declare class OGIAddonWSListener {
+  private socket;
+  eventEmitter: events.EventEmitter;
+  addon: OGIAddon;
+  constructor(ogiAddon: OGIAddon, eventEmitter: events.EventEmitter);
+  private userInputAsked;
+  private registerMessageReceiver;
+  private waitForEventToRespond;
+  respondToMessage(messageID: string, response: any, originalEvent: EventResponse<any> | undefined): void;
+  waitForResponseFromServer<T>(messageID: string): Promise<T>;
+  send(event: OGIAddonClientSentEvent, args: ClientSentEventTypes[OGIAddonClientSentEvent]): string;
+  close(): void;
+}
+//#endregion
+//#region src/EventResponse.d.ts
+declare class EventResponse<T> {
+  data: T | undefined;
+  deffered: boolean;
+  resolved: boolean;
+  progress: number;
+  logs: string[];
+  failed: string | undefined;
+  onInputAsked?: (screen: ConfigurationBuilder, name: string, description: string) => Promise<{
+    [key: string]: boolean | string | number;
+  }>;
+  constructor(onInputAsked?: (screen: ConfigurationBuilder, name: string, description: string) => Promise<{
+    [key: string]: boolean | string | number;
+  }>);
+  defer(promise?: () => Promise<void>): void;
+  /**
+   * Resolve the event with data. This acts like a promise resolve, and will stop the event from being processed further. **You must always call this method when you are done with the event.**
+   * @param data {T}
+   */
+  resolve(data: T): void;
+  /**
+   * Completes the event and resolves it, but does not return any data. **You must always call this method when you are done with the event.**
+   */
+  complete(): void;
+  fail(message: string): void;
+  /**
+   * Logs a message to the event. This is useful for debugging and logging information to the user.
+   * @param message {string}
+   */
+  log(message: string): void;
+  /**
+   * Send a screen to the client to ask for input. Use the `ConfigurationBuilder` system to build the screen. Once sent to the user, the addon cannot change the screen.
+   * @async
+   * @param name {string}
+   * @param description {string}
+   * @param screen {ConfigurationBuilder}
+   * @returns {Promise<{ [key: string]: boolean | string | number }>}
+   */
+  askForInput(name: string, description: string, screen: ConfigurationBuilder): Promise<{
+    [key: string]: boolean | string | number;
+  }>;
+}
+//#endregion
+export { WebsocketMessageServer as _, EventListenerTypes as a, OGIAddonClientSentEvent as c, OGIAddonServerSentEvent as d, SearchTool as f, WebsocketMessageClient as g, VERSION as h, CustomTask as i, OGIAddonConfiguration as l, StoreData as m, BasicLibraryInfo as n, LibraryInfo as o, SetupEventResponse as p, ClientSentEventTypes as r, OGIAddon as s, EventResponse as t, OGIAddonEvent as u, ZodLibraryInfo as v };
+//# sourceMappingURL=EventResponse-D1c-Df5W.d.cts.map

package/build/EventResponse.cjs

@@ -1,83 +1,59 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/EventResponse.ts
-var EventResponse_exports = {};
-__export(EventResponse_exports, {
-  default: () => EventResponse
-});
-module.exports = __toCommonJS(EventResponse_exports);
+//#region src/EventResponse.ts
 var EventResponse = class {
-  data = void 0;
-  deffered = false;
-  resolved = false;
-  progress = 0;
-  logs = [];
-  failed = void 0;
-  onInputAsked;
-  constructor(onInputAsked) {
-    this.onInputAsked = onInputAsked;
-  }
-  defer(promise) {
-    this.deffered = true;
-    if (promise) {
-      promise();
-    }
-  }
-  /**
-   * Resolve the event with data. This acts like a promise resolve, and will stop the event from being processed further. **You must always call this method when you are done with the event.**
-   * @param data {T}
-   */
-  resolve(data) {
-    this.resolved = true;
-    this.data = data;
-  }
-  /**
-   * Completes the event and resolves it, but does not return any data. **You must always call this method when you are done with the event.**
-   */
-  complete() {
-    this.resolved = true;
-  }
-  fail(message) {
-    this.resolved = true;
-    this.failed = message;
-  }
-  /**
-   * Logs a message to the event. This is useful for debugging and logging information to the user.
-   * @param message {string}
-   */
-  log(message) {
-    this.logs.push(message);
-  }
-  /**
-   * Send a screen to the client to ask for input. Use the `ConfigurationBuilder` system to build the screen. Once sent to the user, the addon cannot change the screen.
-   * @async
-   * @param name {string}
-   * @param description {string}
-   * @param screen {ConfigurationBuilder}
-   * @returns {Promise<{ [key: string]: boolean | string | number }>}
-   */
-  async askForInput(name, description, screen) {
-    if (!this.onInputAsked) {
-      throw new Error("No input asked callback");
-    }
-    return await this.onInputAsked(screen, name, description);
-  }
+	data = void 0;
+	deffered = false;
+	resolved = false;
+	progress = 0;
+	logs = [];
+	failed = void 0;
+	onInputAsked;
+	constructor(onInputAsked) {
+		this.onInputAsked = onInputAsked;
+	}
+	defer(promise) {
+		this.deffered = true;
+		if (promise) promise();
+	}
+	/**
+	* Resolve the event with data. This acts like a promise resolve, and will stop the event from being processed further. **You must always call this method when you are done with the event.**
+	* @param data {T}
+	*/
+	resolve(data) {
+		this.resolved = true;
+		this.data = data;
+	}
+	/**
+	* Completes the event and resolves it, but does not return any data. **You must always call this method when you are done with the event.**
+	*/
+	complete() {
+		this.resolved = true;
+	}
+	fail(message) {
+		this.resolved = true;
+		this.failed = message;
+	}
+	/**
+	* Logs a message to the event. This is useful for debugging and logging information to the user.
+	* @param message {string}
+	*/
+	log(message) {
+		this.logs.push(message);
+	}
+	/**
+	* Send a screen to the client to ask for input. Use the `ConfigurationBuilder` system to build the screen. Once sent to the user, the addon cannot change the screen.
+	* @async
+	* @param name {string}
+	* @param description {string}
+	* @param screen {ConfigurationBuilder}
+	* @returns {Promise<{ [key: string]: boolean | string | number }>}
+	*/
+	async askForInput(name, description, screen) {
+		if (!this.onInputAsked) throw new Error("No input asked callback");
+		return await this.onInputAsked(screen, name, description);
+	}
 };
+
+//#endregion
+module.exports = EventResponse;
 //# sourceMappingURL=EventResponse.cjs.map

package/build/EventResponse.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/EventResponse.ts"],"sourcesContent":["import { ConfigurationBuilder } from './main';\n\nexport default class EventResponse<T> {\n  data: T | undefined = undefined;\n  deffered: boolean = false;\n  resolved: boolean = false;\n  progress: number = 0;\n  logs: string[] = [];\n  failed: string | undefined = undefined;\n  onInputAsked?: (\n    screen: ConfigurationBuilder,\n    name: string,\n    description: string\n  ) => Promise<{ [key: string]: boolean | string | number }>;\n\n  constructor(\n    onInputAsked?: (\n      screen: ConfigurationBuilder,\n      name: string,\n      description: string\n    ) => Promise<{ [key: string]: boolean | string | number }>\n  ) {\n    this.onInputAsked = onInputAsked;\n  }\n\n  public defer(promise?: () => Promise<void>) {\n    this.deffered = true;\n    // include this to make it easier to use the defer method with async functions\n    if (promise) {\n      promise();\n    }\n  }\n\n  /**\n   * Resolve the event with data. This acts like a promise resolve, and will stop the event from being processed further. **You must always call this method when you are done with the event.**\n   * @param data {T}\n   */\n  public resolve(data: T) {\n    this.resolved = true;\n    this.data = data;\n  }\n\n  /**\n   * Completes the event and resolves it, but does not return any data. **You must always call this method when you are done with the event.**\n   */\n  public complete() {\n    this.resolved = true;\n  }\n\n  public fail(message: string) {\n    this.resolved = true;\n    this.failed = message;\n  }\n\n  /**\n   * Logs a message to the event. This is useful for debugging and logging information to the user.\n   * @param message {string}\n   */\n  public log(message: string) {\n    this.logs.push(message);\n  }\n\n  /**\n   * Send a screen to the client to ask for input. Use the `ConfigurationBuilder` system to build the screen. Once sent to the user, the addon cannot change the screen.\n   * @async\n   * @param name {string}\n   * @param description {string}\n   * @param screen {ConfigurationBuilder}\n   * @returns {Promise<{ [key: string]: boolean | string | number }>}\n   */\n  public async askForInput(\n    name: string,\n    description: string,\n    screen: ConfigurationBuilder\n  ): Promise<{ [key: string]: boolean | string | number }> {\n    if (!this.onInputAsked) {\n      throw new Error('No input asked callback');\n    }\n    return await this.onInputAsked(screen, name, description);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,IAAqB,gBAArB,MAAsC;AAAA,EACpC,OAAsB;AAAA,EACtB,WAAoB;AAAA,EACpB,WAAoB;AAAA,EACpB,WAAmB;AAAA,EACnB,OAAiB,CAAC;AAAA,EAClB,SAA6B;AAAA,EAC7B;AAAA,EAMA,YACE,cAKA;AACA,SAAK,eAAe;AAAA,EACtB;AAAA,EAEO,MAAM,SAA+B;AAC1C,SAAK,WAAW;AAEhB,QAAI,SAAS;AACX,cAAQ;AAAA,IACV;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,QAAQ,MAAS;AACtB,SAAK,WAAW;AAChB,SAAK,OAAO;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKO,WAAW;AAChB,SAAK,WAAW;AAAA,EAClB;AAAA,EAEO,KAAK,SAAiB;AAC3B,SAAK,WAAW;AAChB,SAAK,SAAS;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,IAAI,SAAiB;AAC1B,SAAK,KAAK,KAAK,OAAO;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAa,YACX,MACA,aACA,QACuD;AACvD,QAAI,CAAC,KAAK,cAAc;AACtB,YAAM,IAAI,MAAM,yBAAyB;AAAA,IAC3C;AACA,WAAO,MAAM,KAAK,aAAa,QAAQ,MAAM,WAAW;AAAA,EAC1D;AACF;","names":[]}
+{"version":3,"file":"EventResponse.cjs","names":[],"sources":["../src/EventResponse.ts"],"sourcesContent":["import { ConfigurationBuilder } from './main';\n\nexport default class EventResponse<T> {\n  data: T | undefined = undefined;\n  deffered: boolean = false;\n  resolved: boolean = false;\n  progress: number = 0;\n  logs: string[] = [];\n  failed: string | undefined = undefined;\n  onInputAsked?: (\n    screen: ConfigurationBuilder,\n    name: string,\n    description: string\n  ) => Promise<{ [key: string]: boolean | string | number }>;\n\n  constructor(\n    onInputAsked?: (\n      screen: ConfigurationBuilder,\n      name: string,\n      description: string\n    ) => Promise<{ [key: string]: boolean | string | number }>\n  ) {\n    this.onInputAsked = onInputAsked;\n  }\n\n  public defer(promise?: () => Promise<void>) {\n    this.deffered = true;\n    // include this to make it easier to use the defer method with async functions\n    if (promise) {\n      promise();\n    }\n  }\n\n  /**\n   * Resolve the event with data. This acts like a promise resolve, and will stop the event from being processed further. **You must always call this method when you are done with the event.**\n   * @param data {T}\n   */\n  public resolve(data: T) {\n    this.resolved = true;\n    this.data = data;\n  }\n\n  /**\n   * Completes the event and resolves it, but does not return any data. **You must always call this method when you are done with the event.**\n   */\n  public complete() {\n    this.resolved = true;\n  }\n\n  public fail(message: string) {\n    this.resolved = true;\n    this.failed = message;\n  }\n\n  /**\n   * Logs a message to the event. This is useful for debugging and logging information to the user.\n   * @param message {string}\n   */\n  public log(message: string) {\n    this.logs.push(message);\n  }\n\n  /**\n   * Send a screen to the client to ask for input. Use the `ConfigurationBuilder` system to build the screen. Once sent to the user, the addon cannot change the screen.\n   * @async\n   * @param name {string}\n   * @param description {string}\n   * @param screen {ConfigurationBuilder}\n   * @returns {Promise<{ [key: string]: boolean | string | number }>}\n   */\n  public async askForInput(\n    name: string,\n    description: string,\n    screen: ConfigurationBuilder\n  ): Promise<{ [key: string]: boolean | string | number }> {\n    if (!this.onInputAsked) {\n      throw new Error('No input asked callback');\n    }\n    return await this.onInputAsked(screen, name, description);\n  }\n}\n"],"mappings":";;AAEA,IAAqB,gBAArB,MAAsC;CACpC,OAAsB;CACtB,WAAoB;CACpB,WAAoB;CACpB,WAAmB;CACnB,OAAiB,EAAE;CACnB,SAA6B;CAC7B;CAMA,YACE,cAKA;AACA,OAAK,eAAe;;CAGtB,AAAO,MAAM,SAA+B;AAC1C,OAAK,WAAW;AAEhB,MAAI,QACF,UAAS;;;;;;CAQb,AAAO,QAAQ,MAAS;AACtB,OAAK,WAAW;AAChB,OAAK,OAAO;;;;;CAMd,AAAO,WAAW;AAChB,OAAK,WAAW;;CAGlB,AAAO,KAAK,SAAiB;AAC3B,OAAK,WAAW;AAChB,OAAK,SAAS;;;;;;CAOhB,AAAO,IAAI,SAAiB;AAC1B,OAAK,KAAK,KAAK,QAAQ;;;;;;;;;;CAWzB,MAAa,YACX,MACA,aACA,QACuD;AACvD,MAAI,CAAC,KAAK,aACR,OAAM,IAAI,MAAM,0BAA0B;AAE5C,SAAO,MAAM,KAAK,aAAa,QAAQ,MAAM,YAAY"}

package/build/EventResponse.d.cts

@@ -1,45 +1,2 @@
-import { ConfigurationBuilder } from './config/ConfigurationBuilder.cjs';
-
-declare class EventResponse<T> {
-    data: T | undefined;
-    deffered: boolean;
-    resolved: boolean;
-    progress: number;
-    logs: string[];
-    failed: string | undefined;
-    onInputAsked?: (screen: ConfigurationBuilder, name: string, description: string) => Promise<{
-        [key: string]: boolean | string | number;
-    }>;
-    constructor(onInputAsked?: (screen: ConfigurationBuilder, name: string, description: string) => Promise<{
-        [key: string]: boolean | string | number;
-    }>);
-    defer(promise?: () => Promise<void>): void;
-    /**
-     * Resolve the event with data. This acts like a promise resolve, and will stop the event from being processed further. **You must always call this method when you are done with the event.**
-     * @param data {T}
-     */
-    resolve(data: T): void;
-    /**
-     * Completes the event and resolves it, but does not return any data. **You must always call this method when you are done with the event.**
-     */
-    complete(): void;
-    fail(message: string): void;
-    /**
-     * Logs a message to the event. This is useful for debugging and logging information to the user.
-     * @param message {string}
-     */
-    log(message: string): void;
-    /**
-     * Send a screen to the client to ask for input. Use the `ConfigurationBuilder` system to build the screen. Once sent to the user, the addon cannot change the screen.
-     * @async
-     * @param name {string}
-     * @param description {string}
-     * @param screen {ConfigurationBuilder}
-     * @returns {Promise<{ [key: string]: boolean | string | number }>}
-     */
-    askForInput(name: string, description: string, screen: ConfigurationBuilder): Promise<{
-        [key: string]: boolean | string | number;
-    }>;
-}
-
-export { EventResponse as default };
+import { t as EventResponse } from "./EventResponse-D1c-Df5W.cjs";
+export = EventResponse;

package/build/EventResponse.d.mts

@@ -0,0 +1,2 @@
+import { t as EventResponse } from "./EventResponse-CQhmdz3C.mjs";
+export { EventResponse as default };