@ragemp-mango/core 2.0.6-beta.0

package/dist/app/interfaces/index.d.ts

@@ -0,0 +1,157 @@
+export { C as ControllerMetadata, a as CronTimerMetadata, E as EveryTickTimerMetadata, I as IntervalTimerMetadata, M as ModuleMetadata, b as TimeoutTimerMetadata, T as TimerMetadata } from '../../module-metadata.interface-B3bn1vqq.js';
+import { I as InjectableScope } from '../../injectable-scope.enum-CjyQMpW2.js';
+export { B as BodyParameter, C as CustomParameter, a as ErrorFilter, E as EventMetadata, G as Guard, I as Interceptor, M as MethodParameter, b as ParamParameter, P as PipelineMetadata, c as PlayerParameter, R as RequestParameter, d as ResponseParameter } from '../../event-metadata.interface-CREizDNq.js';
+import { E as EventEmmiter } from '../../event-emmiter.interface-7Ne9W8SM.js';
+export { S as ScriptEventHandler } from '../../script-event-handler.interface-vUr_v6tV.js';
+export { E as ExecutionContext, M as MangoRequest, a as MangoResponse } from '../../execution-context.interface-DpRN4oVj.js';
+export { R as RPCMetadata } from '../../rpc-metadata.interface-DS-GqgqA.js';
+import { E as EventDestination } from '../../event-destination.enum-DT8jJFwR.js';
+import { S as ScriptEventHandler, E as EventHandler } from '../../script-event-handler.interface-B-Th4Ssg.js';
+import { R as RPCCallOptions } from '../../rpc-call-options.interface-BJ5mHrvT.js';
+import { R as RPCResult } from '../../rpc-result.interface-C758heM0.js';
+import { S as ScriptRPCHandler } from '../../script-rpc-handler.interface-DBpD9-yk.js';
+import { M as MultiplayerTimers } from '../../multiplayer-timers.interface-CFDTWwAT.js';
+export { a as MultiplayerTimer } from '../../multiplayer-timers.interface-CFDTWwAT.js';
+import '../../newable.type-BdhG3MZC.js';
+import 'inversify';
+import 'croner';
+import '../../call-handler.interface-DVdaknsB.js';
+import '../../injection-token.type-dQTkkP6p.js';
+import '../../pipe-transform.interface-BlzOrUy3.js';
+import '../../method-param-type.enum-BfrJ8zqa.js';
+import '../../execution-context-type.enum-fwYPtPvp.js';
+import '../../rpc-error.interface-CeaZLqzE.js';
+
+interface RPCPayload<TBody = unknown> {
+    source: EventDestination;
+    destination: EventDestination;
+    webViewId?: string | number | undefined;
+    id: string;
+    rpcName: string;
+    body: TBody;
+}
+
+interface InjectableMetadata {
+    scope: `${InjectableScope}`;
+}
+
+interface MangoPlugin {
+    onBuild?(): Promise<void> | void;
+    beforeStart?(): Promise<void> | void;
+    afterStart?(): Promise<void> | void;
+    beforeScan?(): Promise<void> | void;
+    afterScan?(): Promise<void> | void;
+    beforeBind?(): Promise<void> | void;
+    afterBind?(): Promise<void> | void;
+    beforeLoad?(): Promise<void> | void;
+    afterLoad?(): Promise<void> | void;
+    beforeStop?(): Promise<void> | void;
+    afterStop?(): Promise<void> | void;
+}
+
+interface InternalEventService {
+    readonly $localHandlers: Set<ScriptEventHandler>;
+    readonly $internalHandlers: Set<EventHandler>;
+    readonly $remoteHandlers: Set<ScriptEventHandler>;
+    on<E extends keyof MangoEvents.CustomClientEvent>(eventName: E, callback: (body: Parameters<MangoEvents.CustomClientEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    on<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomClientEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    once<E extends keyof MangoEvents.CustomClientEvent>(eventName: E, callback: (body: Parameters<MangoEvents.CustomClientEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    once<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomClientEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    emit<E extends keyof MangoEvents.CustomClientEvent>(eventName: E, body?: MangoEvents.CustomClientEvent[E]): void;
+    emit<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomClientEvent>, body?: unknown): void;
+    onServer<E extends keyof MangoEvents.CustomServerToPlayerEvent>(eventName: E, callback: (body: Parameters<MangoEvents.CustomServerToPlayerEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    onServer<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    onceServer<E extends keyof MangoEvents.CustomServerToPlayerEvent>(eventName: E, callback: (body: Parameters<MangoEvents.CustomServerToPlayerEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    onceServer<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    emitServer<E extends keyof MangoEvents.CustomPlayerToServerEvent>(eventName: E, body?: Parameters<MangoEvents.CustomPlayerToServerEvent[E]>[0]): void;
+    emitServer<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>, body?: unknown): void;
+    onWebView<E extends keyof MangoEvents.CustomWebViewToClientEvent>(id: string | number, eventName: E, callback: (body: Parameters<MangoEvents.CustomWebViewToClientEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    onWebView<E extends string>(id: string | number, eventName: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    onceWebView<E extends keyof MangoEvents.CustomWebViewToClientEvent>(id: string | number, eventName: E, callback: (body: Parameters<MangoEvents.CustomWebViewToClientEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    onceWebView<E extends string>(id: string | number, eventName: Exclude<E, keyof MangoEvents.CustomWebViewToClientEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    emitWebView<E extends keyof MangoEvents.CustomClientToWebViewEvent>(id: string | number, eventName: E, body?: Parameters<MangoEvents.CustomClientToWebViewEvent[E]>[0]): void;
+    emitWebView<E extends string>(id: string | number, eventName: Exclude<E, keyof MangoEvents.CustomClientToWebViewEvent>, body?: unknown): void;
+    on<E extends keyof MangoEvents.CustomServerEvent>(eventName: E, callback: (body: Parameters<MangoEvents.CustomServerEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    on<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    once<E extends keyof MangoEvents.CustomServerEvent>(eventName: E, callback: (body: Parameters<MangoEvents.CustomServerEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    once<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerEvent>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    emit<E extends keyof MangoEvents.CustomServerEvent>(eventName: E, body?: MangoEvents.CustomServerEvent[E]): void;
+    emit<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerEvent>, body?: any): void;
+    onPlayer<E extends keyof MangoEvents.CustomPlayerToServerEvent, U extends PlayerMp>(eventName: E, callback: (player: U, body: Parameters<MangoEvents.CustomPlayerToServerEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    onPlayer<E extends string, U extends PlayerMp>(eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>, callback: (player: U, body: unknown) => void | Promise<void>): ScriptEventHandler;
+    oncePlayer<E extends keyof MangoEvents.CustomPlayerToServerEvent, U extends PlayerMp>(eventName: E, callback: (player: U, body: Parameters<MangoEvents.CustomPlayerToServerEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    oncePlayer<E extends string, U extends PlayerMp>(eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>, callback: (player: U, body: unknown) => void | Promise<void>): ScriptEventHandler;
+    onRemote<E extends keyof MangoEvents.CustomPlayerToServerEvent, U extends PlayerMp>(eventName: E, callback: (player: U, body: Parameters<MangoEvents.CustomPlayerToServerEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    onRemote<E extends string, U extends PlayerMp>(eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>, callback: (player: U, body: unknown) => void | Promise<void>): ScriptEventHandler;
+    onceRemote<E extends keyof MangoEvents.CustomPlayerToServerEvent, U extends PlayerMp>(eventName: E, callback: (player: U, body: Parameters<MangoEvents.CustomPlayerToServerEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    onceRemote<E extends string, U extends PlayerMp>(eventName: Exclude<E, keyof MangoEvents.CustomPlayerToServerEvent>, callback: (player: U, body: unknown) => void | Promise<void>): ScriptEventHandler;
+    emitPlayers<E extends keyof MangoEvents.CustomServerToPlayerEvent, U extends PlayerMp>(player: U[], eventName: E, body?: Parameters<MangoEvents.CustomServerToPlayerEvent[E]>[0]): void;
+    emitPlayers<E extends string, U extends PlayerMp>(player: U[], eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>, body?: unknown): void;
+    emitPlayersUnreliable<E extends keyof MangoEvents.CustomServerToPlayerEvent, U extends PlayerMp>(player: U[], eventName: E, body?: Parameters<MangoEvents.CustomServerToPlayerEvent[E]>[0]): void;
+    emitPlayersUnreliable<E extends string, U extends PlayerMp>(player: U[], eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>, body?: unknown): void;
+    emitAllPlayers<E extends keyof MangoEvents.CustomServerToPlayerEvent>(eventName: E, body?: Parameters<MangoEvents.CustomServerToPlayerEvent[E]>[0]): void;
+    emitAllPlayers<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>, body?: unknown): void;
+    emitAllPlayersUnreliable<E extends keyof MangoEvents.CustomServerToPlayerEvent>(eventName: E, body?: Parameters<MangoEvents.CustomServerToPlayerEvent[E]>[0]): void;
+    emitAllPlayersUnreliable<E extends string>(eventName: Exclude<E, keyof MangoEvents.CustomServerToPlayerEvent>, body?: unknown): void;
+    onWebView<E extends keyof MangoEvents.CustomWebViewToServerEvent, U extends PlayerMp>(id: string | number, eventName: E, callback: (player: U, body: Parameters<MangoEvents.CustomWebViewToServerEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    onWebView<E extends string, U extends PlayerMp>(id: string | number, eventName: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>, callback: (player: U, body: unknown) => void | Promise<void>): ScriptEventHandler;
+    onceWebView<E extends keyof MangoEvents.CustomWebViewToServerEvent, U extends PlayerMp>(id: string | number, eventName: E, callback: (player: U, body: Parameters<MangoEvents.CustomWebViewToServerEvent[E]>[0]) => void | Promise<void>): ScriptEventHandler;
+    onceWebView<E extends string, U extends PlayerMp>(id: string | number, eventName: Exclude<E, keyof MangoEvents.CustomWebViewToServerEvent>, callback: (player: U, body: unknown) => void | Promise<void>): ScriptEventHandler;
+    emitWebViews<E extends keyof MangoEvents.CustomServerToWebViewEvent, U extends PlayerMp>(player: U[], id: string | number, eventName: E, body?: Parameters<MangoEvents.CustomServerToWebViewEvent[E]>[0]): void;
+    emitWebViews<E extends string, U extends PlayerMp>(player: U[], id: string | number, eventName: Exclude<E, keyof MangoEvents.CustomServerToWebViewEvent>, body?: unknown): void;
+    emitAllWebViews<E extends keyof MangoEvents.CustomServerToWebViewEvent>(id: string | number, eventName: E, body?: Parameters<MangoEvents.CustomServerToWebViewEvent[E]>[0]): void;
+    emitAllWebViews<E extends string>(id: string | number, eventName: Exclude<E, keyof MangoEvents.CustomServerToWebViewEvent>, body?: unknown): void;
+    emitAllWebViewsUnreliable<E extends keyof MangoEvents.CustomServerToWebViewEvent>(id: string | number, eventName: E, body?: Parameters<MangoEvents.CustomServerToWebViewEvent[E]>[0]): void;
+    emitAllWebViewsUnreliable<E extends string>(id: string | number, eventName: Exclude<E, keyof MangoEvents.CustomServerToWebViewEvent>, body?: unknown): void;
+    $onInternal(eventName: string, handler: (body: unknown) => void | Promise<void>): EventHandler;
+    $onceInternal(eventName: string, handler: (body: unknown) => void | Promise<void>): EventHandler;
+}
+
+interface InternalRPCService {
+    $serverHandlers: Map<string, ScriptRPCHandler>;
+    $webViewHandlers: Map<string, ScriptRPCHandler>;
+    $clientHandlers: Map<string, ScriptRPCHandler>;
+    call<E extends keyof MangoRPC.CustomClientRPC>(rpcName: E, body?: Parameters<MangoRPC.CustomClientRPC[E]>[0], options?: RPCCallOptions): Promise<RPCResult<ReturnType<MangoRPC.CustomClientRPC[E]>>>;
+    call<E extends string>(rpcName: Exclude<E, keyof MangoRPC.CustomClientRPC>, body?: unknown, options?: RPCCallOptions): Promise<RPCResult<unknown>>;
+    onRequest<E extends keyof MangoRPC.CustomClientRPC>(rpcName: E, handler: (body: Parameters<MangoRPC.CustomClientRPC[E]>[0]) => ReturnType<MangoRPC.CustomClientRPC[E]>): ScriptRPCHandler;
+    onRequest<E extends string>(rpcName: Exclude<E, keyof MangoRPC.CustomClientRPC>, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;
+    callServer<E extends keyof MangoRPC.CustomClientToServerRPC>(rpcName: E, body?: Parameters<MangoRPC.CustomClientToServerRPC[E]>[0], options?: RPCCallOptions): Promise<RPCResult<MangoRPC.CustomServerToClientRPC[E]>>;
+    callServer<E extends string>(rpcName: Exclude<E, keyof MangoRPC.CustomClientToServerRPC>, body?: unknown, options?: RPCCallOptions): Promise<RPCResult>;
+    onServerRequest<E extends keyof MangoRPC.CustomServerToClientRPC>(rpcName: E, handler: (body: Parameters<MangoRPC.CustomServerToClientRPC[E]>[0]) => ReturnType<MangoRPC.CustomServerToClientRPC[E]>): ScriptRPCHandler;
+    onServerRequest<E extends string>(rpcName: Exclude<E, keyof MangoRPC.CustomServerToClientRPC>, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;
+    callWebView<E extends keyof MangoRPC.CustomClientToWebviewRPC>(id: string | number, rpcName: E, body?: Parameters<MangoRPC.CustomClientToWebviewRPC[E]>[0], options?: RPCCallOptions): Promise<RPCResult<MangoRPC.CustomClientToWebviewRPC[E]>>;
+    callWebView<E extends string>(id: string | number, rpcName: Exclude<E, keyof MangoRPC.CustomClientToWebviewRPC>, body?: unknown, options?: RPCCallOptions): Promise<RPCResult>;
+    onWebViewRequest<E extends keyof MangoRPC.CustomWebViewToClientRPC>(id: string | number, rpcName: E, handler: (body: Parameters<MangoRPC.CustomWebViewToClientRPC[E]>[0]) => ReturnType<MangoRPC.CustomWebViewToClientRPC[E]>): ScriptRPCHandler;
+    onWebViewRequest<E extends string>(id: string | number, rpcName: Exclude<E, keyof MangoRPC.CustomWebViewToClientRPC>, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;
+    call<E extends keyof MangoRPC.CustomServerRPC>(rpcName: E, body?: Parameters<MangoRPC.CustomServerRPC[E]>[0], options?: RPCCallOptions): Promise<RPCResult<ReturnType<MangoRPC.CustomServerRPC[E]>>>;
+    call<E extends string>(rpcName: Exclude<E, keyof MangoRPC.CustomServerRPC>, body?: unknown, options?: RPCCallOptions): Promise<RPCResult<unknown>>;
+    onRequest<E extends keyof MangoRPC.CustomServerRPC>(rpcName: E, handler: (body: Parameters<MangoRPC.CustomServerRPC[E]>[0]) => ReturnType<MangoRPC.CustomServerRPC[E]>): ScriptRPCHandler;
+    onRequest<E extends string>(rpcName: Exclude<E, keyof MangoRPC.CustomServerRPC>, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;
+    callPlayer<E extends keyof MangoRPC.CustomServerToClientRPC, U extends PlayerMp>(player: U, rpcName: E, body?: Parameters<MangoRPC.CustomServerToClientRPC[E]>[0], options?: RPCCallOptions): Promise<RPCResult<ReturnType<MangoRPC.CustomServerToClientRPC[E]>>>;
+    callPlayer<E extends string, U extends PlayerMp>(player: U, rpcName: Exclude<E, keyof MangoRPC.CustomServerToClientRPC>, body?: unknown, options?: RPCCallOptions): Promise<RPCResult>;
+    onPlayerRequest<E extends keyof MangoRPC.CustomClientToServerRPC, U extends PlayerMp>(rpcName: E, handler: (sender: U, body: Parameters<MangoRPC.CustomClientToServerRPC[E]>[0]) => ReturnType<MangoRPC.CustomClientToServerRPC[E]>): ScriptRPCHandler;
+    onPlayerRequest<E extends string, U extends PlayerMp>(rpcName: Exclude<E, keyof MangoRPC.CustomClientToServerRPC>, handler: (sender: U, body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;
+    callWebView<E extends keyof MangoRPC.CustomServerToWebViewRPC, U extends PlayerMp>(player: U, id: string | number, rpcName: E, body?: Parameters<MangoRPC.CustomServerToWebViewRPC[E]>[0], options?: RPCCallOptions): Promise<RPCResult<ReturnType<MangoRPC.CustomServerToWebViewRPC[E]>>>;
+    callWebView<E extends string, U extends PlayerMp>(player: U, id: string | number, rpcName: Exclude<E, keyof MangoRPC.CustomServerToWebViewRPC>, body?: unknown, options?: RPCCallOptions): Promise<RPCResult>;
+    onWebViewRequest<E extends string, U extends PlayerMp>(id: string | number, rpcName: Exclude<E, keyof MangoRPC.CustomWebViewToServerRPC>, handler: (player: U, body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;
+    onWebViewRequest<E extends keyof MangoRPC.CustomWebViewToServerRPC, U extends PlayerMp>(id: string | number, rpcName: E, handler: (player: U, body: Parameters<MangoRPC.CustomWebViewToServerRPC[E]>[0]) => ReturnType<MangoRPC.CustomWebViewToServerRPC[E]>): ScriptRPCHandler;
+}
+
+interface InternalWebViewService {
+    $onCreate(listener: (id: string | number, webView: BrowserMp) => void): void;
+}
+
+interface MultiplayerService {
+    parseInternalArgs<U = unknown, T = unknown>(...args: any): {
+        player?: U;
+        body?: T;
+    };
+    log(arg: any, ...args: any[]): void;
+    logError(arg: any, ...args: any[]): void;
+    logWarning(arg: any, ...args: any[]): void;
+    logDebug(arg: any, ...args: any[]): void;
+    Timers: MultiplayerTimers;
+    Events: EventEmmiter;
+}
+
+export { EventEmmiter, type InjectableMetadata, type InternalEventService, type InternalRPCService, type InternalWebViewService, type MangoPlugin, type MultiplayerService, MultiplayerTimers, type RPCPayload };

package/dist/app/interfaces/index.js

@@ -0,0 +1,2 @@
+import "../../chunk-M55YEQ7J.js";
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/app/module/index.d.ts

@@ -0,0 +1,27 @@
+import { N as Newable } from '../../newable.type-BdhG3MZC.js';
+import { D as DynamicModule } from '../../call-handler.interface-DVdaknsB.js';
+import { M as ModuleMetadata } from '../../module-metadata.interface-B3bn1vqq.js';
+export { a as Module, M as ModuleContainer } from '../../controller-Ss0TVrxQ.js';
+import 'inversify';
+import '../../injection-token.type-dQTkkP6p.js';
+import '../../injectable-scope.enum-CjyQMpW2.js';
+import '../../event-metadata.interface-CREizDNq.js';
+import '../../pipe-transform.interface-BlzOrUy3.js';
+import '../../method-param-type.enum-BfrJ8zqa.js';
+import '../../execution-context.interface-DpRN4oVj.js';
+import '../../execution-context-type.enum-fwYPtPvp.js';
+import '../../rpc-error.interface-CeaZLqzE.js';
+import '../../rpc-metadata.interface-DS-GqgqA.js';
+import 'croner';
+import '../../script-rpc-handler.interface-DBpD9-yk.js';
+import '../../script-event-handler.interface-vUr_v6tV.js';
+
+declare class ModuleMetadataReader {
+    private readonly loggerService;
+    read(module: Newable | DynamicModule | Promise<DynamicModule>): Promise<ModuleMetadata>;
+    private getPipeline;
+    private getExportTokens;
+    private separateProviders;
+}
+
+export { ModuleMetadataReader };

package/dist/app/module/index.js

@@ -0,0 +1,16 @@
+import {
+  Module,
+  ModuleContainer,
+  ModuleMetadataReader
+} from "../../chunk-73LIJA6X.js";
+import "../../chunk-TBWHLT75.js";
+import "../../chunk-DJZCOYB3.js";
+import "../../chunk-DXPVUDXD.js";
+import "../../chunk-E6IQL4S6.js";
+import "../../chunk-7QVYU63E.js";
+export {
+  Module,
+  ModuleContainer,
+  ModuleMetadataReader
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/app/module-tree/index.d.ts

@@ -0,0 +1,56 @@
+import { a as Module, C as Controller } from '../../controller-Ss0TVrxQ.js';
+import { Tree } from '../utils/index.js';
+import { D as DynamicModule } from '../../call-handler.interface-DVdaknsB.js';
+import { N as Newable } from '../../newable.type-BdhG3MZC.js';
+import '../../module-metadata.interface-B3bn1vqq.js';
+import '../../event-metadata.interface-CREizDNq.js';
+import '../../pipe-transform.interface-BlzOrUy3.js';
+import '../../method-param-type.enum-BfrJ8zqa.js';
+import '../../execution-context.interface-DpRN4oVj.js';
+import '../../execution-context-type.enum-fwYPtPvp.js';
+import '../../rpc-error.interface-CeaZLqzE.js';
+import '../../rpc-metadata.interface-DS-GqgqA.js';
+import 'croner';
+import 'inversify';
+import '../../injection-token.type-dQTkkP6p.js';
+import '../../script-rpc-handler.interface-DBpD9-yk.js';
+import '../../script-event-handler.interface-vUr_v6tV.js';
+import '../../injectable-scope.enum-CjyQMpW2.js';
+
+declare class AppRuntime {
+    private readonly eventHandler;
+    private readonly rpcHandler;
+    private readonly globalGuards;
+    private readonly globalInterceptors;
+    private readonly globalPipes;
+    private readonly globalErrorFilters;
+    private readonly loggerService;
+    private readonly enableShutdownHooks;
+    boot(resolvedTree: Tree<Module>): Promise<void>;
+    shutdown(resolvedTree: Tree<Module>): Promise<void>;
+    private registerListeners;
+    registerTimers(controller: Controller): void;
+    private mapErrorFilters;
+    private runLifecycleMethods;
+    private runLifecycleMethod;
+}
+
+declare class ModuleDependencyBinder {
+    private readonly globalAppContainer;
+    private readonly loggerService;
+    private readonly containerOptions?;
+    bind(resolvedTree: Tree<Module>): Promise<void>;
+    private bindProvider;
+}
+
+declare class ModuleTreeScanner {
+    private readonly moduleMetadataReader;
+    private readonly controllerMetadataReader;
+    private readonly loggerService;
+    scan(classRef: Newable | DynamicModule | Promise<DynamicModule>): Promise<Tree<Module>>;
+    private scanModules;
+    private scanControllers;
+    private checkCircularDependency;
+}
+
+export { AppRuntime, ModuleDependencyBinder, ModuleTreeScanner };

package/dist/app/module-tree/index.js

@@ -0,0 +1,25 @@
+import {
+  AppRuntime,
+  ModuleDependencyBinder,
+  ModuleTreeScanner
+} from "../../chunk-CW7WAA3P.js";
+import "../../chunk-73LIJA6X.js";
+import "../../chunk-AO6BXG54.js";
+import "../../chunk-2ADQZWQE.js";
+import "../../chunk-RYOUF322.js";
+import "../../chunk-PGWRESZG.js";
+import "../../chunk-SKPH3K2M.js";
+import "../../chunk-HK7QTFPA.js";
+import "../../chunk-TBWHLT75.js";
+import "../../chunk-M55YEQ7J.js";
+import "../../chunk-DJZCOYB3.js";
+import "../../chunk-6YEWPMZJ.js";
+import "../../chunk-DXPVUDXD.js";
+import "../../chunk-E6IQL4S6.js";
+import "../../chunk-7QVYU63E.js";
+export {
+  AppRuntime,
+  ModuleDependencyBinder,
+  ModuleTreeScanner
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/app/pipeline/index.d.ts

@@ -0,0 +1,5 @@
+export { b as ExecutionContextBase, c as MangoRequestBase, d as MangoResponseBase } from '../../execution-context.interface-DpRN4oVj.js';
+import '../../newable.type-BdhG3MZC.js';
+import 'inversify';
+import '../../execution-context-type.enum-fwYPtPvp.js';
+import '../../rpc-error.interface-CeaZLqzE.js';

package/dist/app/pipeline/index.js

@@ -0,0 +1,14 @@
+import {
+  ExecutionContextBase,
+  MangoRequestBase,
+  MangoResponseBase
+} from "../../chunk-AO6BXG54.js";
+import "../../chunk-DJZCOYB3.js";
+import "../../chunk-DXPVUDXD.js";
+import "../../chunk-7QVYU63E.js";
+export {
+  ExecutionContextBase,
+  MangoRequestBase,
+  MangoResponseBase
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/app/services/index.d.ts

@@ -0,0 +1,37 @@
+import { E as EventHandler } from '../../script-event-handler.interface-B-Th4Ssg.js';
+import { E as EventEmmiter } from '../../event-emmiter.interface-7Ne9W8SM.js';
+import { S as ScriptEventHandler } from '../../script-event-handler.interface-vUr_v6tV.js';
+import { R as RPCCallOptions } from '../../rpc-call-options.interface-BJ5mHrvT.js';
+import { R as RPCResult } from '../../rpc-result.interface-C758heM0.js';
+import { S as ScriptRPCHandler } from '../../script-rpc-handler.interface-DBpD9-yk.js';
+import { L as LoggerService } from '../../logger-service.interface-BGV-o_Fx.js';
+import '../../rpc-error.interface-CeaZLqzE.js';
+
+declare abstract class BaseEventService<T extends Record<string, any>> {
+    protected $eventEmmiter: EventEmmiter;
+    protected readonly $localHandlers: Set<ScriptEventHandler>;
+    protected readonly $internalHandlers: Set<ScriptEventHandler>;
+    protected readonly $remoteHandlers: Set<ScriptEventHandler>;
+    protected $internalEventNames: Set<string>;
+    constructor($eventEmmiter: EventEmmiter);
+    on<E extends keyof T>(eventName: E, callback: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptEventHandler;
+    on<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    once<E extends keyof T>(eventName: E, callback: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptEventHandler;
+    once<E extends string>(eventName: Exclude<E, keyof T>, callback: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+    emit<E extends keyof T>(eventName: E, body?: T[E]): void;
+    emit<E extends string>(eventName: E, body?: unknown): void;
+    protected $onInternal(eventName: string, handler: (body: unknown) => void | Promise<void>): EventHandler;
+    protected $onceInternal(eventName: string, handler: (body: unknown) => void | Promise<void>): ScriptEventHandler;
+}
+
+declare class BaseRPCService<T extends Record<string, any>> {
+    protected readonly $loggerService: LoggerService;
+    protected readonly $TIMEOUT = 2000;
+    private readonly $localHandlers;
+    call<E extends keyof T>(rpcName: E, body?: Parameters<T[E]>[0], options?: RPCCallOptions): Promise<RPCResult<ReturnType<T[E]>>>;
+    call<E extends string>(rpcName: E, body?: unknown, options?: RPCCallOptions): Promise<RPCResult<unknown>>;
+    onRequest<E extends keyof T>(rpcName: E, handler: (body: Parameters<T[E]>[0]) => ReturnType<T[E]>): ScriptRPCHandler;
+    onRequest<E extends string>(rpcName: E, handler: (body: unknown) => unknown | Promise<unknown>): ScriptRPCHandler;
+}
+
+export { BaseEventService, BaseRPCService };

package/dist/app/services/index.js

@@ -0,0 +1,14 @@
+import {
+  BaseEventService,
+  BaseRPCService
+} from "../../chunk-2ADQZWQE.js";
+import "../../chunk-HK7QTFPA.js";
+import "../../chunk-DJZCOYB3.js";
+import "../../chunk-6YEWPMZJ.js";
+import "../../chunk-DXPVUDXD.js";
+import "../../chunk-7QVYU63E.js";
+export {
+  BaseEventService,
+  BaseRPCService
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/app/utils/index.d.ts

@@ -0,0 +1,16 @@
+declare class TreeNode<T> {
+    value: T;
+    children: TreeNode<T>[];
+    constructor(value: T);
+    addChild(child: TreeNode<T>): void;
+    removeChild(child: TreeNode<T>): void;
+}
+declare class Tree<T> {
+    root: TreeNode<T>;
+    constructor(value: T);
+    traverse(callback: (node: TreeNode<T>) => void): void;
+    asyncTraverse(callback: (node: TreeNode<T>) => Promise<void>): Promise<void>;
+    toString(): string;
+}
+
+export { Tree, TreeNode };

package/dist/app/utils/index.js

@@ -0,0 +1,10 @@
+import {
+  Tree,
+  TreeNode
+} from "../../chunk-RYOUF322.js";
+import "../../chunk-7QVYU63E.js";
+export {
+  Tree,
+  TreeNode
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/call-handler.interface-DVdaknsB.d.ts

@@ -0,0 +1,52 @@
+import { N as Newable } from './newable.type-BdhG3MZC.js';
+import { interfaces } from 'inversify';
+import { I as InjectionToken } from './injection-token.type-dQTkkP6p.js';
+import { I as InjectableScope } from './injectable-scope.enum-CjyQMpW2.js';
+
+type OptionalFactoryDependency = {
+    token: InjectionToken;
+    optional: boolean;
+};
+
+type Provider<T = unknown> = Newable<T> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider;
+interface ClassProvider<T = unknown> {
+    provide: InjectionToken;
+    useClass: Newable<T>;
+    scope?: `${InjectableScope}`;
+}
+interface ValueProvider<T = unknown> {
+    provide: InjectionToken;
+    useValue: T;
+}
+interface FactoryProvider<T = unknown> {
+    provide: InjectionToken;
+    useFactory: (...args: any[]) => T | Promise<T>;
+    inject?: (InjectionToken | OptionalFactoryDependency)[];
+    scope?: `${InjectableScope}`;
+}
+interface ExistingProvider {
+    provide: InjectionToken;
+    useExisting: InjectionToken;
+}
+
+interface ModuleOptions {
+    imports?: (Newable | DynamicModule | Promise<DynamicModule>)[];
+    controllers?: Newable[];
+    providers?: Provider[];
+    exports?: (InjectionToken | Provider)[];
+    container?: interfaces.ContainerOptions;
+}
+
+interface DynamicModule<T = unknown> extends ModuleOptions {
+    module: Newable<T>;
+    global?: boolean | undefined;
+}
+
+interface CallHandler<T = unknown> {
+    handle(options?: {
+        send: boolean;
+    }): T;
+    return(value: T): void;
+}
+
+export type { ClassProvider as C, DynamicModule as D, ExistingProvider as E, FactoryProvider as F, ModuleOptions as M, OptionalFactoryDependency as O, Provider as P, ValueProvider as V, CallHandler as a };