@ragemp-mango/core 2.0.6-beta.0

package/dist/chunk-TBWHLT75.js

@@ -0,0 +1,61 @@
+// src/app/enums/app-enviroment.enum.ts
+var AppEnviroment = /* @__PURE__ */ (function(AppEnviroment2) {
+  AppEnviroment2[AppEnviroment2["Client"] = 0] = "Client";
+  AppEnviroment2[AppEnviroment2["Server"] = 1] = "Server";
+  return AppEnviroment2;
+})({});
+
+// src/app/enums/core-metadata-key.enum.ts
+var CoreMetadataKey = /* @__PURE__ */ (function(CoreMetadataKey2) {
+  CoreMetadataKey2["Injectable"] = "mango:injectable";
+  CoreMetadataKey2["Inject"] = "mango:inject";
+  CoreMetadataKey2["Module"] = "mango:module";
+  CoreMetadataKey2["GlobalModule"] = "mango:global-module";
+  CoreMetadataKey2["Controller"] = "mango:controller-options";
+  CoreMetadataKey2["ControllerEvents"] = "mango:controller-events";
+  CoreMetadataKey2["ControllerRPCs"] = "mango:controller-rpcs";
+  CoreMetadataKey2["ControllerParams"] = "mango:controller-rpc-params";
+  CoreMetadataKey2["Guards"] = "mango:guards";
+  CoreMetadataKey2["Interceptors"] = "mango:interceptors";
+  CoreMetadataKey2["Pipes"] = "mango:pipes";
+  CoreMetadataKey2["Catch"] = "mango:catch";
+  CoreMetadataKey2["ErrorFilters"] = "mango:error-filters";
+  CoreMetadataKey2["Timers"] = "mango:timers";
+  return CoreMetadataKey2;
+})({});
+
+// src/app/enums/event-destination.enum.ts
+var EventDestination = /* @__PURE__ */ (function(EventDestination2) {
+  EventDestination2["Server"] = "server";
+  EventDestination2["Client"] = "client";
+  EventDestination2["WebView"] = "webview";
+  return EventDestination2;
+})({});
+
+// src/app/enums/execution-context-type.enum.ts
+var ExecutionContextType = /* @__PURE__ */ (function(ExecutionContextType2) {
+  ExecutionContextType2["Event"] = "event";
+  ExecutionContextType2["RPC"] = "rpc";
+  return ExecutionContextType2;
+})({});
+
+// src/app/enums/method-param-type.enum.ts
+var MethodParamType = /* @__PURE__ */ (function(MethodParamType2) {
+  MethodParamType2["Body"] = "body";
+  MethodParamType2["Custom"] = "custom";
+  MethodParamType2["Param"] = "param";
+  MethodParamType2["Player"] = "player";
+  MethodParamType2["Request"] = "request";
+  MethodParamType2["Response"] = "response";
+  MethodParamType2["Index"] = "index";
+  return MethodParamType2;
+})({});
+
+export {
+  AppEnviroment,
+  CoreMetadataKey,
+  EventDestination,
+  ExecutionContextType,
+  MethodParamType
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vc3JjL2FwcC9lbnVtcy9hcHAtZW52aXJvbWVudC5lbnVtLnRzIiwgIi4uL3NyYy9hcHAvZW51bXMvY29yZS1tZXRhZGF0YS1rZXkuZW51bS50cyIsICIuLi9zcmMvYXBwL2VudW1zL2V2ZW50LWRlc3RpbmF0aW9uLmVudW0udHMiLCAiLi4vc3JjL2FwcC9lbnVtcy9leGVjdXRpb24tY29udGV4dC10eXBlLmVudW0udHMiLCAiLi4vc3JjL2FwcC9lbnVtcy9tZXRob2QtcGFyYW0tdHlwZS5lbnVtLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgZW51bSBBcHBFbnZpcm9tZW50IHtcbiAgICBDbGllbnQsXG4gICAgU2VydmVyLFxufVxuIiwgImV4cG9ydCBlbnVtIENvcmVNZXRhZGF0YUtleSB7XG4gICAgLy8gR2VuZXJhbFxuICAgIEluamVjdGFibGUgPSAnbWFuZ286aW5qZWN0YWJsZScsXG4gICAgSW5qZWN0ID0gJ21hbmdvOmluamVjdCcsXG4gICAgTW9kdWxlID0gJ21hbmdvOm1vZHVsZScsXG4gICAgR2xvYmFsTW9kdWxlID0gJ21hbmdvOmdsb2JhbC1tb2R1bGUnLFxuICAgIENvbnRyb2xsZXIgPSAnbWFuZ286Y29udHJvbGxlci1vcHRpb25zJyxcbiAgICAvLyBFdmVudHMgJiBSUENcbiAgICBDb250cm9sbGVyRXZlbnRzID0gJ21hbmdvOmNvbnRyb2xsZXItZXZlbnRzJyxcbiAgICBDb250cm9sbGVyUlBDcyA9ICdtYW5nbzpjb250cm9sbGVyLXJwY3MnLFxuICAgIENvbnRyb2xsZXJQYXJhbXMgPSAnbWFuZ286Y29udHJvbGxlci1ycGMtcGFyYW1zJyxcbiAgICAvLyBQaXBlbGluZVxuICAgIEd1YXJkcyA9ICdtYW5nbzpndWFyZHMnLFxuICAgIEludGVyY2VwdG9ycyA9ICdtYW5nbzppbnRlcmNlcHRvcnMnLFxuICAgIFBpcGVzID0gJ21hbmdvOnBpcGVzJyxcbiAgICAvLyBFcnJvclxuICAgIENhdGNoID0gJ21hbmdvOmNhdGNoJyxcbiAgICBFcnJvckZpbHRlcnMgPSAnbWFuZ286ZXJyb3ItZmlsdGVycycsXG4gICAgLy9cbiAgICBUaW1lcnMgPSAnbWFuZ286dGltZXJzJyxcbn1cbiIsICJleHBvcnQgZW51bSBFdmVudERlc3RpbmF0aW9uIHtcbiAgICBTZXJ2ZXIgPSAnc2VydmVyJyxcbiAgICBDbGllbnQgPSAnY2xpZW50JyxcbiAgICBXZWJWaWV3ID0gJ3dlYnZpZXcnLFxufVxuIiwgImV4cG9ydCBlbnVtIEV4ZWN1dGlvbkNvbnRleHRUeXBlIHtcbiAgICBFdmVudCA9ICdldmVudCcsXG4gICAgUlBDID0gJ3JwYycsXG59XG4iLCAiZXhwb3J0IGVudW0gTWV0aG9kUGFyYW1UeXBlIHtcbiAgICBCb2R5ID0gJ2JvZHknLFxuICAgIEN1c3RvbSA9ICdjdXN0b20nLFxuICAgIFBhcmFtID0gJ3BhcmFtJyxcbiAgICBQbGF5ZXIgPSAncGxheWVyJyxcbiAgICBSZXF1ZXN0ID0gJ3JlcXVlc3QnLFxuICAgIFJlc3BvbnNlID0gJ3Jlc3BvbnNlJyxcbiAgICBJbmRleCA9ICdpbmRleCcsXG59XG4iXSwKICAibWFwcGluZ3MiOiAiO0FBQU8sSUFBS0EsZ0JBQUFBLDBCQUFBQSxnQkFBQUE7OztTQUFBQTs7OztBQ0FMLElBQUtDLGtCQUFBQSwwQkFBQUEsa0JBQUFBOzs7Ozs7Ozs7Ozs7Ozs7U0FBQUE7Ozs7QUNBTCxJQUFLQyxtQkFBQUEsMEJBQUFBLG1CQUFBQTs7OztTQUFBQTs7OztBQ0FMLElBQUtDLHVCQUFBQSwwQkFBQUEsdUJBQUFBOzs7U0FBQUE7Ozs7QUNBTCxJQUFLQyxrQkFBQUEsMEJBQUFBLGtCQUFBQTs7Ozs7Ozs7U0FBQUE7OyIsCiAgIm5hbWVzIjogWyJBcHBFbnZpcm9tZW50IiwgIkNvcmVNZXRhZGF0YUtleSIsICJFdmVudERlc3RpbmF0aW9uIiwgIkV4ZWN1dGlvbkNvbnRleHRUeXBlIiwgIk1ldGhvZFBhcmFtVHlwZSJdCn0K

package/dist/constants/index.d.ts

@@ -0,0 +1,8 @@
+declare const LOGGER_SERVICE = "LOGGER_SERVICE";
+declare const EVENT_SERVICE = "EVENT_SERVICE";
+declare const RPC_SERVICE = "RPC_SERVICE";
+declare const MODULE_CONTAINER = "MODULE_CONTAINER";
+declare const REFLECTOR_SERVICE = "REFLECTOR_SERVICE";
+declare const TIMER_SERVICE = "TIMER_SERVICE";
+
+export { EVENT_SERVICE, LOGGER_SERVICE, MODULE_CONTAINER, REFLECTOR_SERVICE, RPC_SERVICE, TIMER_SERVICE };

package/dist/constants/index.js

@@ -0,0 +1,18 @@
+import {
+  EVENT_SERVICE,
+  LOGGER_SERVICE,
+  MODULE_CONTAINER,
+  REFLECTOR_SERVICE,
+  RPC_SERVICE,
+  TIMER_SERVICE
+} from "../chunk-DJZCOYB3.js";
+import "../chunk-7QVYU63E.js";
+export {
+  EVENT_SERVICE,
+  LOGGER_SERVICE,
+  MODULE_CONTAINER,
+  REFLECTOR_SERVICE,
+  RPC_SERVICE,
+  TIMER_SERVICE
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/controller-Ss0TVrxQ.d.ts

@@ -0,0 +1,30 @@
+import { M as ModuleMetadata, C as ControllerMetadata } from './module-metadata.interface-B3bn1vqq.js';
+import { S as ScriptRPCHandler } from './script-rpc-handler.interface-DBpD9-yk.js';
+import { S as ScriptEventHandler } from './script-event-handler.interface-vUr_v6tV.js';
+import { Container } from 'inversify';
+
+declare class ModuleContainer extends Container {
+}
+
+declare class Module {
+    readonly controllers: Controller[];
+    container: ModuleContainer;
+    parent: Module | undefined;
+    metadata: ModuleMetadata;
+    instance: {
+        [key: string]: Function;
+    };
+    repetitiveImports: Set<Module>;
+}
+
+declare class Controller {
+    metadata: ControllerMetadata;
+    instance: {
+        [key: string]: Function;
+    };
+    owner: Module;
+    eventHandlers: ScriptEventHandler[];
+    rpcHandlers: ScriptRPCHandler[];
+}
+
+export { Controller as C, ModuleContainer as M, Module as a };

package/dist/custom-decorator.type-BHRvXIGz.d.ts

@@ -0,0 +1,5 @@
+type CustomDecorator<TKey = string> = MethodDecorator & ClassDecorator & {
+    KEY: TKey;
+};
+
+export type { CustomDecorator as C };

package/dist/decorators/index.d.ts

@@ -0,0 +1,90 @@
+import { C as ControllerOptions, I as InjectableOptions } from '../injectable-options.interface-8Gp9oRY6.js';
+import { N as Newable } from '../newable.type-BdhG3MZC.js';
+import { I as InjectionToken } from '../injection-token.type-dQTkkP6p.js';
+import { M as ModuleOptions } from '../call-handler.interface-DVdaknsB.js';
+import { C as CustomDecorator } from '../custom-decorator.type-BHRvXIGz.js';
+import { a as ErrorFilter, G as Guard, I as Interceptor, E as EventMetadata } from '../event-metadata.interface-CREizDNq.js';
+import { P as Pipe } from '../pipe-transform.interface-BlzOrUy3.js';
+import { CronOptions } from 'croner';
+import { E as ExecutionContext } from '../execution-context.interface-DpRN4oVj.js';
+import { R as RPCMetadata } from '../rpc-metadata.interface-DS-GqgqA.js';
+import * as inversify from 'inversify';
+import { interfaces } from 'inversify';
+import '../injectable-scope.enum-CjyQMpW2.js';
+import '../method-param-type.enum-BfrJ8zqa.js';
+import '../execution-context-type.enum-fwYPtPvp.js';
+import '../rpc-error.interface-CeaZLqzE.js';
+
+declare function Controller<T extends Newable>(options?: ControllerOptions): (target: T) => T;
+
+declare function Global<T extends Newable>(): (target: T) => T;
+
+declare function Inject<T = unknown>(key?: InjectionToken<T>): PropertyDecorator & ParameterDecorator;
+
+declare function Injectable<T extends Newable>(options?: InjectableOptions): (target: T) => T;
+
+declare function Module<T extends Newable>(options?: ModuleOptions): (target: T) => T;
+
+declare function Optional(): PropertyDecorator & ParameterDecorator;
+
+declare function SetMetadata<K extends string = string, V = unknown>(key: K, value: V): CustomDecorator;
+
+declare function Catch<T extends Newable>(...exceptions: unknown[]): (target: T) => T;
+
+declare function UseFilters(...filters: (Newable<ErrorFilter> | ErrorFilter)[]): ClassDecorator & MethodDecorator;
+
+declare function OnInternal(eventName: string): MethodDecorator;
+
+declare function OnWebView(id: string | number, eventName?: string): MethodDecorator;
+
+declare function On(eventName?: string): MethodDecorator;
+
+declare function OnceInternal(eventName: string): MethodDecorator;
+
+declare function Once(eventName?: string): MethodDecorator;
+
+declare function OnceWebView(id: string | number, eventName?: string): MethodDecorator;
+
+declare function Body(...pipes: (Newable<Pipe> | Pipe)[]): ParameterDecorator;
+
+declare function Index(key: number, ...pipes: (Newable<Pipe> | Pipe)[]): ParameterDecorator;
+
+declare function Request(): ParameterDecorator;
+declare function Req(): ParameterDecorator;
+
+declare function Param(key: string, ...pipes: (Newable<Pipe> | Pipe)[]): ParameterDecorator;
+
+declare function Response(): ParameterDecorator;
+declare function Res(): ParameterDecorator;
+
+declare function UseGuards(...guards: (Newable<Guard> | Guard)[]): ClassDecorator & MethodDecorator;
+
+declare function UseInterceptors(...interceptors: (Newable<Interceptor> | Interceptor)[]): ClassDecorator & MethodDecorator;
+
+declare function UsePipes(...pipes: (Newable<Pipe> | Pipe)[]): ClassDecorator & MethodDecorator;
+
+declare function OnRequest(rpcName?: string): MethodDecorator;
+
+declare function OnWebViewRequest(id: string | number, rpcName?: string): MethodDecorator;
+
+declare function Cron(pattern: string | Date, options?: CronOptions): MethodDecorator;
+
+declare function EveryTick(name?: string): MethodDecorator;
+
+declare function Interval(timeout: number): MethodDecorator;
+declare function Interval(name: string, timeout: number): MethodDecorator;
+
+declare function Timeout(timeout: number): MethodDecorator;
+declare function Timeout(name: string, value: number): MethodDecorator;
+
+declare function applyDecorators(...decorators: (ClassDecorator | MethodDecorator | PropertyDecorator)[]): <TFunction extends Function, Y>(target: TFunction | Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<Y>) => void;
+
+declare function createEventDecorator(type: EventMetadata['type'], name?: string, webViewId?: string | number): MethodDecorator;
+
+declare function createParamDecorator<TInput = unknown, TOutput = unknown>(factory: (data: TInput, ctx: ExecutionContext) => TOutput): <TInput_1 = unknown>(data?: TInput_1, ...pipes: (Newable<Pipe> | Pipe)[]) => ParameterDecorator;
+
+declare function createRPCDecorator(type: RPCMetadata['type'], name?: string, webViewId?: string | number): MethodDecorator;
+
+declare function forwardRef<T = unknown>(fn: () => interfaces.ServiceIdentifier<T>): inversify.LazyServiceIdentifier<T>;
+
+export { Body, Catch, Controller, Cron, EveryTick, Global, Index, Inject, Injectable, Interval, Module, On, OnInternal, OnRequest, OnWebView, OnWebViewRequest, Once, OnceInternal, OnceWebView, Optional, Param, Req, Request, Res, Response, SetMetadata, Timeout, UseFilters, UseGuards, UseInterceptors, UsePipes, applyDecorators, createEventDecorator, createParamDecorator, createRPCDecorator, forwardRef };

package/dist/decorators/index.js

@@ -0,0 +1,91 @@
+import {
+  Body,
+  Catch,
+  Controller,
+  Cron,
+  EveryTick,
+  Global,
+  Index,
+  Inject,
+  Injectable,
+  Interval,
+  Module,
+  On,
+  OnInternal,
+  OnRequest,
+  OnWebView,
+  OnWebViewRequest,
+  Once,
+  OnceInternal,
+  OnceWebView,
+  Optional,
+  Param,
+  Req,
+  Request,
+  Res,
+  Response,
+  SetMetadata,
+  Timeout,
+  UseFilters,
+  UseGuards,
+  UseInterceptors,
+  UsePipes,
+  applyDecorators,
+  createEventDecorator,
+  createParamDecorator,
+  createRPCDecorator,
+  forwardRef
+} 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 {
+  Body,
+  Catch,
+  Controller,
+  Cron,
+  EveryTick,
+  Global,
+  Index,
+  Inject,
+  Injectable,
+  Interval,
+  Module,
+  On,
+  OnInternal,
+  OnRequest,
+  OnWebView,
+  OnWebViewRequest,
+  Once,
+  OnceInternal,
+  OnceWebView,
+  Optional,
+  Param,
+  Req,
+  Request,
+  Res,
+  Response,
+  SetMetadata,
+  Timeout,
+  UseFilters,
+  UseGuards,
+  UseInterceptors,
+  UsePipes,
+  applyDecorators,
+  createEventDecorator,
+  createParamDecorator,
+  createRPCDecorator,
+  forwardRef
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/enums/index.d.ts

@@ -0,0 +1,66 @@
+export { I as InjectableScope } from '../injectable-scope.enum-CjyQMpW2.js';
+
+declare enum ErrorMessage {
+    TooManyRequests = "Too many requests.",
+    EventNameMustBeString = "The event name must be a string.",
+    EventNameMustBeUnique = "The event name must be unique.",
+    EventNotAllowedInClient = "The event is not allowed in the client environment.",
+    EventNotAllowedInServer = "The event is not allowed in the server environment.",
+    InvalidEventType = "Invalid event type.",
+    InvalidInternalEventName = "The name of the internal event is invalid.",
+    InvalidReturnInEvent = "Cannot return a value from an event.",
+    RPCNameMustBeString = "The RPC name must be a string.",
+    RPCNameMustBeUnique = "The RPC name must be unique.",
+    RPCNotAllowedInClient = "The RPC is not allowed in the client environment.",
+    RPCNotAllowedInServer = "The RPC is not allowed in the server environment.",
+    InvalidRPCType = "Invalid RPC type.",
+    RPCHandlerAlreadyExists = "The RPC handler already exists. Please provide a unique name for the RPC.",
+    RPCResponseAlreadySent = "The RPC response has already been sent.",
+    InvalidErrorFilterDefinition = "Invalid error filter. Error filters must be a class reference or an object with a catch method.",
+    ErrorAlreadyHandledByFilter = "The error already points to a filter.",
+    ExceptionHandlingConflict = "The same exception can only be caught once.",
+    AtLeastOneFilterRequired = "At least one error filter must be provided.",
+    DuplicateErrorFilterDetected = "Duplicate error filter found. Ensure that the same filter is not applied more than once.",
+    WebViewNotFound = "The WebView with the specified id does not exist.",
+    WebViewIdMustBeStringOrNumber = "The WebView id must be a string or number.",
+    InvalidGuardDefinition = "Invalid guard. Guards must be a class reference or an object with a canActivate method.",
+    AtLeastOneGuardRequired = "At least one guard must be provided.",
+    InvalidInterceptorDefinition = "Invalid interceptor. Interceptors must be a class reference or an object with an intercept method.",
+    AtLeastOneInterceptorRequired = "At least one interceptor must be provided.",
+    InvalidInterceptorReturnValue = "The interceptor must return a function.",
+    InvalidPipeDefinition = "Invalid pipe. Pipes must be a class reference or an object with a transform method.",
+    AtLeastOnePipeRequired = "At least one pipe must be provided.",
+    AppAlreadyLoaded = "App is already loaded. Please call the stop method before calling the start method.",
+    AppNotLoaded = "App is not loaded. Please call the start method before calling the stop method.",
+    InvalidInjectionTokenSpecified = "The specified injection token is invalid.",
+    InjectionTokenNotFound = "The injection token could not be found.",
+    ParamKeyMustBeString = "The param key must be a string.",
+    IndexKeyMustBeNumber = "The index key must be a number.",
+    DuplicateDecoratorUsage = "The same decorator can only be used once in the same class.",
+    InvalidControllerOptions = "Invalid controller options found.",
+    InvalidInjectableOptions = "Invalid injectable options found.",
+    InvalidModuleOptions = "Invalid module options found.",
+    MultipleDecoratorsOnSingleParameterNotAllowed = "Cannot apply multiple decorators to the same parameter.",
+    CircularDependencyDetected = "Circular dependency detected.",
+    InvalidModuleDefinition = "The module is invalid.",
+    InvalidExportDefinition = "The export is invalid.",
+    InvalidProviderDefinition = "The provider is invalid.",
+    InvalidParameterDecoratorUsage = "Each parameter must have their its own decorator.",
+    ResponseDecoratorNotAllowedOnEvents = "The @Response() decorator is not allowed on events.",
+    PlayerDecoratorNotAllowedOnClientEvents = "The @Player() decorator is not allowed on client events.",
+    TimerNameMustBeString = "The timer name must be a string."
+}
+
+declare enum RPCResultStatus {
+    Success = 1,
+    Timeout = 2,
+    HandlerNotFound = 3,
+    Unknown = 4,
+    CancelledByGuard = 5,
+    InvalidGuardReturn = 6,
+    TooManyRequests = 7,
+    PlayerDisconnected = 8,
+    PlayerNotFound = 9
+}
+
+export { ErrorMessage, RPCResultStatus };

package/dist/enums/index.js

@@ -0,0 +1,12 @@
+import {
+  ErrorMessage,
+  InjectableScope,
+  RPCResultStatus
+} from "../chunk-DXPVUDXD.js";
+import "../chunk-7QVYU63E.js";
+export {
+  ErrorMessage,
+  InjectableScope,
+  RPCResultStatus
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/errors/index.d.ts

@@ -0,0 +1,23 @@
+declare class MangoError<TDetails = unknown> extends Error {
+    status: number;
+    details: TDetails | undefined;
+    constructor(message: string, status?: number, details?: TDetails);
+}
+
+declare class GuardCancelError extends MangoError {
+    constructor();
+}
+
+declare class GuardInvalidReturnError extends MangoError {
+    constructor();
+}
+
+declare class TooManyRequests extends MangoError {
+    constructor(message?: string);
+}
+
+declare class UnknownError extends MangoError {
+    constructor();
+}
+
+export { GuardCancelError, GuardInvalidReturnError, MangoError, TooManyRequests, UnknownError };

package/dist/errors/index.js

@@ -0,0 +1,17 @@
+import {
+  GuardCancelError,
+  GuardInvalidReturnError,
+  MangoError,
+  TooManyRequests,
+  UnknownError
+} from "../chunk-6YEWPMZJ.js";
+import "../chunk-DXPVUDXD.js";
+import "../chunk-7QVYU63E.js";
+export {
+  GuardCancelError,
+  GuardInvalidReturnError,
+  MangoError,
+  TooManyRequests,
+  UnknownError
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/event-destination.enum-DT8jJFwR.d.ts

@@ -0,0 +1,7 @@
+declare enum EventDestination {
+    Server = "server",
+    Client = "client",
+    WebView = "webview"
+}
+
+export { EventDestination as E };

package/dist/event-emmiter.interface-7Ne9W8SM.d.ts

@@ -0,0 +1,10 @@
+import { S as ScriptEventHandler } from './script-event-handler.interface-vUr_v6tV.js';
+
+interface EventEmmiter {
+    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;
+}
+
+export type { EventEmmiter as E };

package/dist/event-metadata.interface-CREizDNq.d.ts

@@ -0,0 +1,89 @@
+import { N as Newable } from './newable.type-BdhG3MZC.js';
+import { A as ArgumentMetadata, P as Pipe } from './pipe-transform.interface-BlzOrUy3.js';
+import { b as ExecutionContextBase, M as MangoRequest, a as MangoResponse, E as ExecutionContext } from './execution-context.interface-DpRN4oVj.js';
+import { a as CallHandler } from './call-handler.interface-DVdaknsB.js';
+import { M as MethodParamType } from './method-param-type.enum-BfrJ8zqa.js';
+
+interface BodyParameter extends ArgumentMetadata {
+    type: MethodParamType.Body;
+    method: string;
+    index: number;
+    pipes?: (Newable<Pipe> | Pipe)[];
+    data?: string | undefined;
+}
+
+interface CustomParameter extends ArgumentMetadata {
+    type: MethodParamType.Custom;
+    method: string;
+    index: number;
+    pipes?: (Newable<Pipe> | Pipe)[];
+    factory: (data: unknown, context: ExecutionContextBase) => unknown;
+    data?: unknown;
+}
+
+interface IndexParameter extends ArgumentMetadata {
+    type: MethodParamType.Index;
+    method: string;
+    index: number;
+    pipes?: (Newable<Pipe> | Pipe)[];
+    data: number;
+}
+
+interface ParamParameter extends ArgumentMetadata {
+    type: MethodParamType.Param;
+    method: string;
+    index: number;
+    pipes?: (Newable<Pipe> | Pipe)[];
+    data: string;
+}
+
+interface PlayerParameter extends ArgumentMetadata {
+    type: MethodParamType.Player;
+    method: string;
+    index: number;
+    pipes?: (Newable<Pipe> | Pipe)[];
+    data?: string | undefined;
+}
+
+interface RequestParameter extends ArgumentMetadata {
+    type: MethodParamType.Request;
+    method: string;
+    index: number;
+}
+
+interface ResponseParameter extends ArgumentMetadata {
+    type: MethodParamType.Response;
+    method: string;
+    index: number;
+}
+
+type MethodParameter = BodyParameter | CustomParameter | ParamParameter | PlayerParameter | RequestParameter | ResponseParameter | IndexParameter;
+
+interface ErrorFilter<T = unknown, TRequest extends MangoRequest = MangoRequest, TResponse extends MangoResponse = MangoResponse> {
+    catch(error: T, context: ExecutionContext<TRequest, TResponse>): unknown;
+}
+
+interface Guard<TRequest extends MangoRequest = MangoRequest, TResponse extends MangoResponse = MangoResponse> {
+    canActivate(context: ExecutionContext<TRequest, TResponse>): boolean | Promise<boolean>;
+}
+
+interface Interceptor<THandlerResult = unknown, TRequest extends MangoRequest = MangoRequest, TResponse extends MangoResponse = MangoResponse> {
+    intercept(context: ExecutionContext<TRequest, TResponse>, callHandler: CallHandler<THandlerResult>): void | Promise<void>;
+}
+
+interface PipelineMetadata {
+    guards: (Newable<Guard> | Guard)[];
+    interceptors: (Newable<Interceptor> | Interceptor)[];
+    pipes: (Newable<Pipe> | Pipe)[];
+    errorFilters: (Newable<ErrorFilter> | ErrorFilter)[];
+}
+
+interface EventMetadata extends PipelineMetadata {
+    type: 'on' | 'once' | 'onPlayer' | 'oncePlayer' | 'onServer' | 'onceServer' | 'onWebView' | 'onceWebView' | 'onInternal' | 'onceInternal';
+    name: string;
+    method: string;
+    params: MethodParameter[];
+    webViewId?: string | number | undefined;
+}
+
+export type { BodyParameter as B, CustomParameter as C, EventMetadata as E, Guard as G, Interceptor as I, MethodParameter as M, PipelineMetadata as P, RequestParameter as R, ErrorFilter as a, ParamParameter as b, PlayerParameter as c, ResponseParameter as d, IndexParameter as e };

package/dist/execution-context-type.enum-fwYPtPvp.d.ts

@@ -0,0 +1,6 @@
+declare enum ExecutionContextType {
+    Event = "event",
+    RPC = "rpc"
+}
+
+export { ExecutionContextType as E };

package/dist/execution-context.interface-DpRN4oVj.d.ts

@@ -0,0 +1,56 @@
+import { N as Newable } from './newable.type-BdhG3MZC.js';
+import { E as ExecutionContextType } from './execution-context-type.enum-fwYPtPvp.js';
+import { R as RPCError } from './rpc-error.interface-CeaZLqzE.js';
+
+declare class MangoRequestBase<TData = unknown> implements MangoRequest {
+    $body: TData;
+    $player?: PlayerMp;
+    get body(): TData;
+    get player(): PlayerMp | undefined;
+}
+
+declare class MangoResponseBase implements MangoResponse {
+    private readonly $loggerService;
+    $sendListeners: Set<(data: unknown) => void>;
+    $errorListeners: Set<(error: RPCError) => void>;
+    $isSent: boolean;
+    send<TData = unknown>(data?: TData): void;
+    error<TDetails = unknown>(message: string, details?: TDetails): void;
+    $onSend(listener: (data: unknown) => void): void;
+    $onError(listener: (error: RPCError) => void): void;
+}
+
+declare class ExecutionContextBase<TRequest extends MangoRequestBase = MangoRequestBase, TResponse extends MangoResponseBase = MangoResponseBase> implements ExecutionContext<TRequest, TResponse> {
+    $type: ExecutionContextType;
+    $classRef: Newable;
+    $handler: Function;
+    $request: TRequest;
+    $response?: TResponse;
+    $name: string;
+    get type(): ExecutionContextType;
+    get classRef(): Newable;
+    get handler(): Function;
+    get request(): TRequest;
+    get response(): TResponse;
+    get name(): string;
+}
+
+interface MangoRequest<TData = unknown> {
+    readonly body: TData;
+}
+
+interface MangoResponse {
+    send<TData = unknown>(data: TData): void;
+    error<TDetails = unknown>(message: string, details?: TDetails): void;
+}
+
+interface ExecutionContext<TRequest extends MangoRequest = MangoRequest, TResponse extends MangoResponse = MangoResponse> {
+    readonly type: `${ExecutionContextType}`;
+    readonly classRef: Newable;
+    readonly handler: Function;
+    readonly request: TRequest;
+    readonly response?: TResponse;
+    readonly name: string;
+}
+
+export { type ExecutionContext as E, type MangoRequest as M, type MangoResponse as a, ExecutionContextBase as b, MangoRequestBase as c, MangoResponseBase as d };

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+export { EVENT_SERVICE, LOGGER_SERVICE, MODULE_CONTAINER, REFLECTOR_SERVICE, RPC_SERVICE, TIMER_SERVICE } from './constants/index.js';
+export { Body, Catch, Controller, Cron, EveryTick, Global, Index, Inject, Injectable, Interval, Module, On, OnInternal, OnRequest, OnWebView, OnWebViewRequest, Once, OnceInternal, OnceWebView, Optional, Param, Req, Request, Res, Response, SetMetadata, Timeout, UseFilters, UseGuards, UseInterceptors, UsePipes, applyDecorators, createEventDecorator, createParamDecorator, createRPCDecorator, forwardRef } from './decorators/index.js';
+export { ErrorMessage, RPCResultStatus } from './enums/index.js';
+export { I as InjectableScope } from './injectable-scope.enum-CjyQMpW2.js';
+export { GuardCancelError, GuardInvalidReturnError, MangoError, TooManyRequests, UnknownError } from './errors/index.js';
+export { C as ControllerOptions, I as InjectableOptions } from './injectable-options.interface-8Gp9oRY6.js';
+export { a as CallHandler, C as ClassProvider, D as DynamicModule, E as ExistingProvider, F as FactoryProvider, M as ModuleOptions, O as OptionalFactoryDependency, P as Provider, V as ValueProvider } from './call-handler.interface-DVdaknsB.js';
+export { BeforeAppShutdown, OnAppBootstrap, OnAppShutdown, OnModuleDestroy, OnModuleInit } from './interfaces/index.js';
+export { A as ArgumentMetadata, P as Pipe } from './pipe-transform.interface-BlzOrUy3.js';
+export { C as CreateDecoratorOptions, a as CreateDecoratorWithTransformOptions, R as ReflectableDecorator } from './reflectable-decorator.interface-CLOGdtEQ.js';
+export { R as RPCCallOptions } from './rpc-call-options.interface-BJ5mHrvT.js';
+export { R as RPCError } from './rpc-error.interface-CeaZLqzE.js';
+export { R as RPCResult } from './rpc-result.interface-C758heM0.js';
+export { S as ScriptRPCHandler } from './script-rpc-handler.interface-DBpD9-yk.js';
+export { L as LoggerService } from './logger-service.interface-BGV-o_Fx.js';
+export { E as EventHandler, S as ScriptEventHandler } from './script-event-handler.interface-B-Th4Ssg.js';
+export { DefaultValuePipe } from './pipes/index.js';
+export { validateClassProvider, validateControllerOptions, validateErrorFilter, validateEventMetadata, validateEventParameter, validateExistingProvider, validateFactoryProvider, validateGuard, validateInjectableMetadata, validateInjectionToken, validateInterceptor, validateModuleOptions, validatePipe, validateProvider, validateValueProvider } from './schemas/index.js';
+export { ReflectorService, TimerService } from './services/index.js';
+export { Abstract } from './types/index.js';
+export { C as CustomDecorator } from './custom-decorator.type-BHRvXIGz.js';
+export { I as InjectionToken } from './injection-token.type-dQTkkP6p.js';
+export { N as Newable } from './newable.type-BdhG3MZC.js';
+export { N as Nullable } from './nullable.type-C-lE7JU4.js';
+export { generateRandomId, isAsyncFunction, isBoolean, isConstructor, isEmpty, isFunction, isNil, isNumber, isObject, isPromise, isString, isSymbol, isUndefined } from './utils/index.js';
+import './event-metadata.interface-CREizDNq.js';
+import './execution-context.interface-DpRN4oVj.js';
+import './execution-context-type.enum-fwYPtPvp.js';
+import './method-param-type.enum-BfrJ8zqa.js';
+import 'croner';
+import './rpc-metadata.interface-DS-GqgqA.js';
+import 'inversify';
+import './multiplayer-timers.interface-CFDTWwAT.js';