@ragemp-mango/core 2.0.6-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Aurėjus Remeika
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+## Mango Framework
+
+A simple, lightweight, and powerful TypeScript framework for building RageMP servers.
+
+## Features
+
+-   Mango Framework is built with TypeScript and provides a powerful type system for your application.
+-   Mango Framework has a wide range of decorators that allow you to easily create and manage your resource flow.
+-   Mango Framework is built with modularity in mind, allowing you to organize your application into small, reusable pieces.
+-   Mango Framework uses InversifyJS under the hood to provide a powerful dependency injection for your application.
+-   Mango Framework uses controllers to group and listen to events/rpcs together under a single class.
+-   Mango Framework uses Guards, Interceptors, and Error Filters to create a powerful pipeline that allows you to easily manage every incoming event/rpc.
+
+## Documentation
+
+[Documentation](https://ragemp-mango.vercel.app)
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

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

@@ -0,0 +1,26 @@
+import { R as RPCResult } from '../../rpc-result.interface-C758heM0.js';
+import '../../rpc-error.interface-CeaZLqzE.js';
+
+declare const INTERNAL_APP_CONTAINER = "INTERNAL_APP_CONTAINER";
+declare const GLOBAL_APP_CONTAINER = "GLOBAL_APP_CONTAINER";
+declare const APP_ENVIROMENT = "APP_ENVIROMENT";
+declare const GLOBAL_GUARDS = "GLOBAL_GUARDS";
+declare const GLOBAL_INTERCEPTORS = "GLOBAL_INTERCEPTORS";
+declare const GLOBAL_PIPES = "GLOBAL_PIPES";
+declare const GLOBAL_ERROR_FILTERS = "GLOBAL_ERROR_FILTERS";
+declare const PLUGINS = "PLUGINS";
+declare const ENABLE_SHUTDOWN_HOOKS = "ENABLE_SHUTDOWN_HOOKS";
+declare const CONTAINER_OPTIONS = "CONTAINER_OPTIONS";
+declare const LOG_ERROR_STACKTRACE = "LOG_ERROR_STACKTRACE";
+declare const MANGO_LOG_PREFIX = "\uD83E\uDD6D";
+declare const MANGO_REQUEST_FACTORY = "MANGO_REQUEST_FACTORY";
+declare const MANGO_RESPONSE_FACTORY = "MANGO_RESPONSE_FACTORY";
+declare const EXECUTION_CONTEXT_FACTORY = "EXECUTION_CONTEXT_FACTORY";
+declare const MULTIPLAYER_SERVICE = "MULTIPLAYER_SERVICE";
+declare const RPC_RESULT_TIMEOUT: RPCResult;
+declare const RPC_RESULT_HANDLER_NOT_FOUND: RPCResult;
+declare const RPC_RESULT_UNKNOWN: RPCResult;
+declare const RPC_RESULT_PLAYER_DISCONNECTED: RPCResult;
+declare const RPC_RESULT_PLAYER_NOT_FOUND: RPCResult;
+
+export { APP_ENVIROMENT, CONTAINER_OPTIONS, ENABLE_SHUTDOWN_HOOKS, EXECUTION_CONTEXT_FACTORY, GLOBAL_APP_CONTAINER, GLOBAL_ERROR_FILTERS, GLOBAL_GUARDS, GLOBAL_INTERCEPTORS, GLOBAL_PIPES, INTERNAL_APP_CONTAINER, LOG_ERROR_STACKTRACE, MANGO_LOG_PREFIX, MANGO_REQUEST_FACTORY, MANGO_RESPONSE_FACTORY, MULTIPLAYER_SERVICE, PLUGINS, RPC_RESULT_HANDLER_NOT_FOUND, RPC_RESULT_PLAYER_DISCONNECTED, RPC_RESULT_PLAYER_NOT_FOUND, RPC_RESULT_TIMEOUT, RPC_RESULT_UNKNOWN };

package/dist/app/constants/index.js

@@ -0,0 +1,49 @@
+import {
+  APP_ENVIROMENT,
+  CONTAINER_OPTIONS,
+  ENABLE_SHUTDOWN_HOOKS,
+  EXECUTION_CONTEXT_FACTORY,
+  GLOBAL_APP_CONTAINER,
+  GLOBAL_ERROR_FILTERS,
+  GLOBAL_GUARDS,
+  GLOBAL_INTERCEPTORS,
+  GLOBAL_PIPES,
+  INTERNAL_APP_CONTAINER,
+  LOG_ERROR_STACKTRACE,
+  MANGO_LOG_PREFIX,
+  MANGO_REQUEST_FACTORY,
+  MANGO_RESPONSE_FACTORY,
+  MULTIPLAYER_SERVICE,
+  PLUGINS,
+  RPC_RESULT_HANDLER_NOT_FOUND,
+  RPC_RESULT_PLAYER_DISCONNECTED,
+  RPC_RESULT_PLAYER_NOT_FOUND,
+  RPC_RESULT_TIMEOUT,
+  RPC_RESULT_UNKNOWN
+} from "../../chunk-HK7QTFPA.js";
+import "../../chunk-DXPVUDXD.js";
+import "../../chunk-7QVYU63E.js";
+export {
+  APP_ENVIROMENT,
+  CONTAINER_OPTIONS,
+  ENABLE_SHUTDOWN_HOOKS,
+  EXECUTION_CONTEXT_FACTORY,
+  GLOBAL_APP_CONTAINER,
+  GLOBAL_ERROR_FILTERS,
+  GLOBAL_GUARDS,
+  GLOBAL_INTERCEPTORS,
+  GLOBAL_PIPES,
+  INTERNAL_APP_CONTAINER,
+  LOG_ERROR_STACKTRACE,
+  MANGO_LOG_PREFIX,
+  MANGO_REQUEST_FACTORY,
+  MANGO_RESPONSE_FACTORY,
+  MULTIPLAYER_SERVICE,
+  PLUGINS,
+  RPC_RESULT_HANDLER_NOT_FOUND,
+  RPC_RESULT_PLAYER_DISCONNECTED,
+  RPC_RESULT_PLAYER_NOT_FOUND,
+  RPC_RESULT_TIMEOUT,
+  RPC_RESULT_UNKNOWN
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

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

@@ -0,0 +1,70 @@
+import { N as Newable } from '../../newable.type-BdhG3MZC.js';
+import { P as Pipe, A as ArgumentMetadata } from '../../pipe-transform.interface-BlzOrUy3.js';
+import { E as EventHandler } from '../../script-event-handler.interface-B-Th4Ssg.js';
+import { G as Guard, I as Interceptor, a as ErrorFilter, E as EventMetadata } from '../../event-metadata.interface-CREizDNq.js';
+import { C as Controller, M as ModuleContainer } from '../../controller-Ss0TVrxQ.js';
+import { b as ExecutionContextBase } from '../../execution-context.interface-DpRN4oVj.js';
+import { R as RPCMetadata } from '../../rpc-metadata.interface-DS-GqgqA.js';
+import { C as ControllerMetadata } from '../../module-metadata.interface-B3bn1vqq.js';
+import { S as ScriptRPCHandler } from '../../script-rpc-handler.interface-DBpD9-yk.js';
+import { a as CallHandler } from '../../call-handler.interface-DVdaknsB.js';
+import 'inversify';
+import '../../method-param-type.enum-BfrJ8zqa.js';
+import '../../script-event-handler.interface-vUr_v6tV.js';
+import '../../execution-context-type.enum-fwYPtPvp.js';
+import '../../rpc-error.interface-CeaZLqzE.js';
+import 'croner';
+import '../../injection-token.type-dQTkkP6p.js';
+import '../../injectable-scope.enum-CjyQMpW2.js';
+
+declare class ControllerEventHandler {
+    private readonly appEnv;
+    private readonly multiplayerService;
+    private readonly eventService;
+    private readonly controllerFlowHandler;
+    private readonly pipelineHandler;
+    private readonly loggerService;
+    private readonly createMangoRequest;
+    private readonly createExecutionContext;
+    registerEvent(guards: (Newable<Guard> | Guard)[], interceptors: (Newable<Interceptor> | Interceptor)[], pipes: (Newable<Pipe> | Pipe)[], mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][], controller: Controller, event: EventMetadata): EventHandler;
+    private handleEvent;
+}
+
+declare class ControllerFlowHandler {
+    private readonly appEnv;
+    private readonly pipelineHandler;
+    createArgs(controller: Controller, executionContext: ExecutionContextBase, metadata: RPCMetadata | EventMetadata, pipes: (Newable<Pipe> | Pipe)[], player?: PlayerMp): Promise<unknown[]>;
+}
+
+declare class ControllerMetadataReader {
+    private readonly appEnv;
+    private readonly loggerService;
+    read(classRef: Newable): Promise<ControllerMetadata>;
+    private getEvents;
+    private getRPCs;
+    private getMethodParams;
+    private getPipeline;
+    private getTimers;
+}
+
+declare class ControllerRPCHandler {
+    private readonly appEnv;
+    private readonly rpcService;
+    private readonly pipelineHandler;
+    private readonly controllerFlowHandler;
+    private readonly loggerService;
+    private readonly createMangoRequest;
+    private readonly createMangoResponse;
+    private readonly createExecutionContext;
+    registerRPC(guards: (Newable<Guard> | Guard)[], interceptors: (Newable<Interceptor> | Interceptor)[], pipes: (Newable<Pipe> | Pipe)[], mappedErrorFilters: [any | 'MANGO_ANY_ERROR', Newable<ErrorFilter> | ErrorFilter][], controller: Controller, rpc: RPCMetadata): Promise<ScriptRPCHandler>;
+    private handleRPC;
+}
+
+declare class PipelineHandler {
+    private readonly loggerService;
+    goTroughGuards(executionContext: ExecutionContextBase, guards: (Newable<Guard> | Guard)[], container: ModuleContainer): Promise<void>;
+    goThroughInterceptors(executionContext: ExecutionContextBase, interceptors: (Newable<Interceptor> | Interceptor)[], container: ModuleContainer, callHandler: CallHandler): Promise<void>;
+    goTroughPipes(value: unknown, pipes: (Newable<Pipe> | Pipe)[], argumentMetadata: ArgumentMetadata, container: ModuleContainer): Promise<unknown>;
+}
+
+export { Controller, ControllerEventHandler, ControllerFlowHandler, ControllerMetadataReader, ControllerRPCHandler, PipelineHandler };

package/dist/app/controller/index.js

@@ -0,0 +1,24 @@
+import {
+  Controller,
+  ControllerEventHandler,
+  ControllerFlowHandler,
+  ControllerMetadataReader,
+  ControllerRPCHandler,
+  PipelineHandler
+} from "../../chunk-SKPH3K2M.js";
+import "../../chunk-HK7QTFPA.js";
+import "../../chunk-TBWHLT75.js";
+import "../../chunk-DJZCOYB3.js";
+import "../../chunk-6YEWPMZJ.js";
+import "../../chunk-DXPVUDXD.js";
+import "../../chunk-E6IQL4S6.js";
+import "../../chunk-7QVYU63E.js";
+export {
+  Controller,
+  ControllerEventHandler,
+  ControllerFlowHandler,
+  ControllerMetadataReader,
+  ControllerRPCHandler,
+  PipelineHandler
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

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

@@ -0,0 +1,27 @@
+export { E as EventDestination } from '../../event-destination.enum-DT8jJFwR.js';
+export { E as ExecutionContextType } from '../../execution-context-type.enum-fwYPtPvp.js';
+export { M as MethodParamType } from '../../method-param-type.enum-BfrJ8zqa.js';
+
+declare enum AppEnviroment {
+    Client = 0,
+    Server = 1
+}
+
+declare enum CoreMetadataKey {
+    Injectable = "mango:injectable",
+    Inject = "mango:inject",
+    Module = "mango:module",
+    GlobalModule = "mango:global-module",
+    Controller = "mango:controller-options",
+    ControllerEvents = "mango:controller-events",
+    ControllerRPCs = "mango:controller-rpcs",
+    ControllerParams = "mango:controller-rpc-params",
+    Guards = "mango:guards",
+    Interceptors = "mango:interceptors",
+    Pipes = "mango:pipes",
+    Catch = "mango:catch",
+    ErrorFilters = "mango:error-filters",
+    Timers = "mango:timers"
+}
+
+export { AppEnviroment, CoreMetadataKey };

package/dist/app/enums/index.js

@@ -0,0 +1,16 @@
+import {
+  AppEnviroment,
+  CoreMetadataKey,
+  EventDestination,
+  ExecutionContextType,
+  MethodParamType
+} from "../../chunk-TBWHLT75.js";
+import "../../chunk-7QVYU63E.js";
+export {
+  AppEnviroment,
+  CoreMetadataKey,
+  EventDestination,
+  ExecutionContextType,
+  MethodParamType
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/app/index.d.ts

@@ -0,0 +1,138 @@
+export { APP_ENVIROMENT, CONTAINER_OPTIONS, ENABLE_SHUTDOWN_HOOKS, EXECUTION_CONTEXT_FACTORY, GLOBAL_APP_CONTAINER, GLOBAL_ERROR_FILTERS, GLOBAL_GUARDS, GLOBAL_INTERCEPTORS, GLOBAL_PIPES, INTERNAL_APP_CONTAINER, LOG_ERROR_STACKTRACE, MANGO_LOG_PREFIX, MANGO_REQUEST_FACTORY, MANGO_RESPONSE_FACTORY, MULTIPLAYER_SERVICE, PLUGINS, RPC_RESULT_HANDLER_NOT_FOUND, RPC_RESULT_PLAYER_DISCONNECTED, RPC_RESULT_PLAYER_NOT_FOUND, RPC_RESULT_TIMEOUT, RPC_RESULT_UNKNOWN } from './constants/index.js';
+export { ControllerEventHandler, ControllerFlowHandler, ControllerMetadataReader, ControllerRPCHandler, PipelineHandler } from './controller/index.js';
+export { C as Controller, a as Module, M as ModuleContainer } from '../controller-Ss0TVrxQ.js';
+import { AppEnviroment } from './enums/index.js';
+export { CoreMetadataKey } from './enums/index.js';
+export { E as EventDestination } from '../event-destination.enum-DT8jJFwR.js';
+export { E as ExecutionContextType } from '../execution-context-type.enum-fwYPtPvp.js';
+export { M as MethodParamType } from '../method-param-type.enum-BfrJ8zqa.js';
+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 { MultiplayerService, MangoPlugin } from './interfaces/index.js';
+export { InjectableMetadata, InternalEventService, InternalRPCService, InternalWebViewService, RPCPayload } from './interfaces/index.js';
+import { G as Guard, I as Interceptor, a as ErrorFilter } from '../event-metadata.interface-CREizDNq.js';
+export { B as BodyParameter, C as CustomParameter, E as EventMetadata, 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';
+import { S as ScriptEventHandler } from '../script-event-handler.interface-vUr_v6tV.js';
+export { E as ExecutionContext, b as ExecutionContextBase, M as MangoRequest, c as MangoRequestBase, a as MangoResponse, d as MangoResponseBase } from '../execution-context.interface-DpRN4oVj.js';
+export { R as RPCMetadata } from '../rpc-metadata.interface-DS-GqgqA.js';
+import { M as MultiplayerTimers, a as MultiplayerTimer } from '../multiplayer-timers.interface-CFDTWwAT.js';
+export { ModuleMetadataReader } from './module/index.js';
+export { AppRuntime, ModuleDependencyBinder, ModuleTreeScanner } from './module-tree/index.js';
+export { BaseEventService, BaseRPCService } from './services/index.js';
+export { Tree, TreeNode } from './utils/index.js';
+import { Container, interfaces } from 'inversify';
+import { N as Newable } from '../newable.type-BdhG3MZC.js';
+import { P as Pipe } from '../pipe-transform.interface-BlzOrUy3.js';
+import '../rpc-result.interface-C758heM0.js';
+import '../rpc-error.interface-CeaZLqzE.js';
+import '../script-event-handler.interface-B-Th4Ssg.js';
+import '../script-rpc-handler.interface-DBpD9-yk.js';
+import '../call-handler.interface-DVdaknsB.js';
+import '../injection-token.type-dQTkkP6p.js';
+import '../injectable-scope.enum-CjyQMpW2.js';
+import 'croner';
+import '../rpc-call-options.interface-BJ5mHrvT.js';
+import '../logger-service.interface-BGV-o_Fx.js';
+
+declare class RageMPEventEmmiter implements EventEmmiter {
+    private mapEvents;
+    private mapEventsShared;
+    constructor(mapEvents?: Record<string, string>);
+    private getEventName;
+    emit(eventName: string, ...args: any[]): void;
+    on(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler;
+    once(eventName: string, listener: (...args: any[]) => void): ScriptEventHandler;
+    off(eventName: string, listener: (...args: any[]) => void): void;
+}
+
+declare class RageMPMultiplayerService implements MultiplayerService {
+    readonly Timers: MultiplayerTimers;
+    readonly Events: EventEmmiter;
+    constructor();
+    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;
+}
+
+declare class RageMPScriptEvent implements ScriptEventHandler {
+    private eventName;
+    private listener;
+    constructor(eventName: string, listener: (...args: any[]) => void);
+    destroy(): void;
+}
+
+declare class RageMPTimer implements MultiplayerTimer {
+    id: number;
+    interval: number;
+    once: boolean;
+    callback: Function;
+    private clearTimer;
+    lastTick: number;
+    constructor(id: number, interval: number | undefined, once: boolean, callback: Function, clearTimer: Function);
+    destroy(): void;
+}
+
+declare class RageMPTimers implements MultiplayerTimers {
+    private timerIncrementer;
+    private timers;
+    private everyTickHandlers;
+    private isEveryTickRunning;
+    private everyTickMainHandler;
+    get all(): MultiplayerTimer[];
+    get warningThreshold(): number;
+    set warningThreshold(_value: number);
+    get sourceLocationFrameSkipCount(): number;
+    set sourceLocationFrameSkipCount(_value: number);
+    getByID(id: number): MultiplayerTimer | null;
+    private createTimer;
+    setInterval(callback: Function, time: number, ...args: unknown[]): RageMPTimer;
+    setTimeout(callback: Function, time: number, ...args: unknown[]): RageMPTimer;
+    everyTick(callback: Function, ...args: unknown[]): RageMPTimer;
+    nextTick(callback: Function, ...args: unknown[]): RageMPTimer;
+    time(_name?: string): void;
+    timeEnd(_name?: string): void;
+}
+
+declare class App {
+    private readonly moduleTreeScanner;
+    private readonly moduleDependencyBinder;
+    private readonly appRuntime;
+    private readonly internalAppContainer;
+    private readonly plugins;
+    private readonly loggerService;
+    private moduleTree;
+    private loaded;
+    start<T>(rootModule: Newable<T>): Promise<void>;
+    stop(): Promise<void>;
+    private runPluginMethods;
+}
+
+declare class AppBuilder<G extends Guard = Guard, I extends Interceptor = Interceptor, EF extends ErrorFilter = ErrorFilter> {
+    protected readonly enviroment: string;
+    protected readonly internalAppContainer: Container;
+    protected readonly multiplayerService: MultiplayerService;
+    protected readonly plugins: Newable<MangoPlugin>[];
+    private globalContainerOptions;
+    useGlobalGuards(...guards: (Newable<G> | G)[]): this;
+    useGlobalInterceptors(...interceptors: (Newable<I> | I)[]): this;
+    useGlobalPipes(...pipes: (Newable<Pipe> | Pipe)[]): this;
+    useGlobalFilters(...filters: (Newable<EF> | EF)[]): this;
+    usePlugins(...plugins: Newable<MangoPlugin>[]): this;
+    enableShutdownHooks(): this;
+    setContainerOptions(options: interfaces.ContainerOptions, onlyGlobal?: boolean): this;
+    build(): Promise<App>;
+}
+
+declare function createAppBuilder<T extends AppBuilder>({ enviroment, plugins, appBuilderInherit, multiplayerService, }: {
+    enviroment: AppEnviroment;
+    plugins: Newable<MangoPlugin>[];
+    appBuilderInherit: Newable<T>;
+    multiplayerService?: MultiplayerService;
+}): Promise<T>;
+
+export { App, AppBuilder, AppEnviroment, ErrorFilter, EventEmmiter, Guard, Interceptor, MangoPlugin, MultiplayerService, MultiplayerTimer, MultiplayerTimers, RageMPEventEmmiter, RageMPMultiplayerService, RageMPScriptEvent, RageMPTimer, RageMPTimers, ScriptEventHandler, createAppBuilder };

package/dist/app/index.js

@@ -0,0 +1,132 @@
+import {
+  App,
+  AppBuilder,
+  AppRuntime,
+  ModuleDependencyBinder,
+  ModuleTreeScanner,
+  RageMPEventEmmiter,
+  RageMPMultiplayerService,
+  RageMPScriptEvent,
+  RageMPTimer,
+  RageMPTimers,
+  createAppBuilder
+} from "../chunk-CW7WAA3P.js";
+import {
+  Module,
+  ModuleContainer,
+  ModuleMetadataReader
+} from "../chunk-73LIJA6X.js";
+import {
+  ExecutionContextBase,
+  MangoRequestBase,
+  MangoResponseBase
+} from "../chunk-AO6BXG54.js";
+import {
+  BaseEventService,
+  BaseRPCService
+} from "../chunk-2ADQZWQE.js";
+import {
+  Tree,
+  TreeNode
+} from "../chunk-RYOUF322.js";
+import "../chunk-PGWRESZG.js";
+import {
+  Controller,
+  ControllerEventHandler,
+  ControllerFlowHandler,
+  ControllerMetadataReader,
+  ControllerRPCHandler,
+  PipelineHandler
+} from "../chunk-SKPH3K2M.js";
+import {
+  APP_ENVIROMENT,
+  CONTAINER_OPTIONS,
+  ENABLE_SHUTDOWN_HOOKS,
+  EXECUTION_CONTEXT_FACTORY,
+  GLOBAL_APP_CONTAINER,
+  GLOBAL_ERROR_FILTERS,
+  GLOBAL_GUARDS,
+  GLOBAL_INTERCEPTORS,
+  GLOBAL_PIPES,
+  INTERNAL_APP_CONTAINER,
+  LOG_ERROR_STACKTRACE,
+  MANGO_LOG_PREFIX,
+  MANGO_REQUEST_FACTORY,
+  MANGO_RESPONSE_FACTORY,
+  MULTIPLAYER_SERVICE,
+  PLUGINS,
+  RPC_RESULT_HANDLER_NOT_FOUND,
+  RPC_RESULT_PLAYER_DISCONNECTED,
+  RPC_RESULT_PLAYER_NOT_FOUND,
+  RPC_RESULT_TIMEOUT,
+  RPC_RESULT_UNKNOWN
+} from "../chunk-HK7QTFPA.js";
+import {
+  AppEnviroment,
+  CoreMetadataKey,
+  EventDestination,
+  ExecutionContextType,
+  MethodParamType
+} from "../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 {
+  APP_ENVIROMENT,
+  App,
+  AppBuilder,
+  AppEnviroment,
+  AppRuntime,
+  BaseEventService,
+  BaseRPCService,
+  CONTAINER_OPTIONS,
+  Controller,
+  ControllerEventHandler,
+  ControllerFlowHandler,
+  ControllerMetadataReader,
+  ControllerRPCHandler,
+  CoreMetadataKey,
+  ENABLE_SHUTDOWN_HOOKS,
+  EXECUTION_CONTEXT_FACTORY,
+  EventDestination,
+  ExecutionContextBase,
+  ExecutionContextType,
+  GLOBAL_APP_CONTAINER,
+  GLOBAL_ERROR_FILTERS,
+  GLOBAL_GUARDS,
+  GLOBAL_INTERCEPTORS,
+  GLOBAL_PIPES,
+  INTERNAL_APP_CONTAINER,
+  LOG_ERROR_STACKTRACE,
+  MANGO_LOG_PREFIX,
+  MANGO_REQUEST_FACTORY,
+  MANGO_RESPONSE_FACTORY,
+  MULTIPLAYER_SERVICE,
+  MangoRequestBase,
+  MangoResponseBase,
+  MethodParamType,
+  Module,
+  ModuleContainer,
+  ModuleDependencyBinder,
+  ModuleMetadataReader,
+  ModuleTreeScanner,
+  PLUGINS,
+  PipelineHandler,
+  RPC_RESULT_HANDLER_NOT_FOUND,
+  RPC_RESULT_PLAYER_DISCONNECTED,
+  RPC_RESULT_PLAYER_NOT_FOUND,
+  RPC_RESULT_TIMEOUT,
+  RPC_RESULT_UNKNOWN,
+  RageMPEventEmmiter,
+  RageMPMultiplayerService,
+  RageMPScriptEvent,
+  RageMPTimer,
+  RageMPTimers,
+  Tree,
+  TreeNode,
+  createAppBuilder
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K