@open-core/framework 1.0.1-beta.1 → 1.0.4-beta.1

package/dist/server/decorators/throttle.d.ts

@@ -1,9 +1,48 @@
 import type { SecurityAction } from '../types/security.types';
 interface ThrottleOptions {
+    /**
+     * limit of calls per windowMs
+     */
     limit: number;
+    /**
+     * time window for numeric overload
+     */
     windowMs: number;
+    /**
+     * action to perform on exceed limit
+     */
     onExceed?: SecurityAction;
+    /**
+     * custom message to display on exceed limit (ERROR MESSAGE)
+     */
     message?: string;
 }
+/**
+ * Rate-limits how frequently a method can be called by a specific player.
+ *
+ * Uses `RateLimiterService` and a unique key composed of:
+ * `playerID:ClassName:MethodName`.
+ *
+ * ## Overload
+ * - `@Throttle(5, 1000)` → limit = 5 calls per 1000 ms
+ * - `@Throttle({ limit, windowMs, onExceed, message })`
+ *
+ * ## Behavior
+ * If the rate limit is exceeded:
+ * - A `SecurityError` is thrown.
+ * - Optional custom behavior (`onExceed`) may be executed.
+ *
+ * ## Example
+ * ```ts
+ * @Throttle(5, 2000)
+ * async search(player: Server.Player, query: string) { ... }
+ *
+ * @Throttle({ limit: 1, windowMs: 5000, message: "Too fast!" })
+ * async placeOrder(player: Server.Player) { ... }
+ * ```
+ *
+ * @param optionsOrLimit - Number (simple mode) or full config object.
+ * @param windowMs - Time window for numeric overload.
+ */
 export declare function Throttle(optionsOrLimit: number | ThrottleOptions, windowMs?: number): (target: any, propertyKey: string, descriptor?: PropertyDescriptor) => PropertyDescriptor | undefined;
 export {};

package/dist/server/decorators/throttle.js

@@ -4,6 +4,33 @@ exports.Throttle = Throttle;
 const tsyringe_1 = require("tsyringe");
 const rate_limiter_service_1 = require("../services/rate-limiter.service");
 const utils_1 = require("../../utils");
+/**
+ * Rate-limits how frequently a method can be called by a specific player.
+ *
+ * Uses `RateLimiterService` and a unique key composed of:
+ * `playerID:ClassName:MethodName`.
+ *
+ * ## Overload
+ * - `@Throttle(5, 1000)` → limit = 5 calls per 1000 ms
+ * - `@Throttle({ limit, windowMs, onExceed, message })`
+ *
+ * ## Behavior
+ * If the rate limit is exceeded:
+ * - A `SecurityError` is thrown.
+ * - Optional custom behavior (`onExceed`) may be executed.
+ *
+ * ## Example
+ * ```ts
+ * @Throttle(5, 2000)
+ * async search(player: Server.Player, query: string) { ... }
+ *
+ * @Throttle({ limit: 1, windowMs: 5000, message: "Too fast!" })
+ * async placeOrder(player: Server.Player) { ... }
+ * ```
+ *
+ * @param optionsOrLimit - Number (simple mode) or full config object.
+ * @param windowMs - Time window for numeric overload.
+ */
 function Throttle(optionsOrLimit, windowMs) {
     return function (target, propertyKey, descriptor) {
         if (!descriptor) {

package/dist/server/decorators/utils.d.ts

@@ -1,7 +1,57 @@
 import type { BindingScope } from './bind';
+/**
+ * Marks a class as a framework-managed Service.
+ *
+ * The decorator binds the class into the dependency injection
+ * container using the provided scope (default: `singleton`).
+ *
+ * Services represent reusable, stateless or stateful logic such as:
+ * - Business rules
+ * - Utility layers
+ * - Gameplay systems
+ * - Internal modules
+ *
+ * This decorator is a convenience wrapper over `@Bind()`, allowing
+ * future extension of service-specific behavior without changing
+ * end-user code.
+ *
+ * ## Example
+ * ```ts
+ * @Service()
+ * export class InventoryService {
+ *   addItem() { ... }
+ * }
+ * ```
+ *
+ * @param options.scope - Optional binding scope (`singleton` | `transient`)
+ */
 export declare function Service(options?: {
     scope?: BindingScope;
 }): (target: any) => void;
+/**
+ * Marks a class as a Repository within the framework.
+ *
+ * A Repository abstracts persistence operations (e.g., database,
+ * API, in-memory, or hybrid storage). It is registered in the
+ * dependency injection container using the provided scope
+ * (default: `singleton`).
+ *
+ * `@Repo()` is intentionally separate from `@Service()` to clearly
+ * distinguish persistence-oriented classes from business logic.
+ * In the future, repository-specific behavior (caching layers,
+ * transactional wrappers, profiling, etc.) can be attached here
+ * without modifying user code.
+ *
+ * ## Example
+ * ```ts
+ * @Repo()
+ * export class AccountRepository {
+ *   async findById(id: string) { ... }
+ * }
+ * ```
+ *
+ * @param options.scope - Optional binding scope (`singleton` | `transient`)
+ */
 export declare function Repo(options?: {
     scope?: BindingScope;
 }): (target: any) => void;

package/dist/server/decorators/utils.js

@@ -3,10 +3,60 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Service = Service;
 exports.Repo = Repo;
 const bind_1 = require("./bind");
+/**
+ * Marks a class as a framework-managed Service.
+ *
+ * The decorator binds the class into the dependency injection
+ * container using the provided scope (default: `singleton`).
+ *
+ * Services represent reusable, stateless or stateful logic such as:
+ * - Business rules
+ * - Utility layers
+ * - Gameplay systems
+ * - Internal modules
+ *
+ * This decorator is a convenience wrapper over `@Bind()`, allowing
+ * future extension of service-specific behavior without changing
+ * end-user code.
+ *
+ * ## Example
+ * ```ts
+ * @Service()
+ * export class InventoryService {
+ *   addItem() { ... }
+ * }
+ * ```
+ *
+ * @param options.scope - Optional binding scope (`singleton` | `transient`)
+ */
 function Service(options) {
     var _a;
     return (0, bind_1.Bind)((_a = options === null || options === void 0 ? void 0 : options.scope) !== null && _a !== void 0 ? _a : 'singleton');
 }
+/**
+ * Marks a class as a Repository within the framework.
+ *
+ * A Repository abstracts persistence operations (e.g., database,
+ * API, in-memory, or hybrid storage). It is registered in the
+ * dependency injection container using the provided scope
+ * (default: `singleton`).
+ *
+ * `@Repo()` is intentionally separate from `@Service()` to clearly
+ * distinguish persistence-oriented classes from business logic.
+ * In the future, repository-specific behavior (caching layers,
+ * transactional wrappers, profiling, etc.) can be attached here
+ * without modifying user code.
+ *
+ * ## Example
+ * ```ts
+ * @Repo()
+ * export class AccountRepository {
+ *   async findById(id: string) { ... }
+ * }
+ * ```
+ *
+ * @param options.scope - Optional binding scope (`singleton` | `transient`)
+ */
 function Repo(options) {
     var _a;
     return (0, bind_1.Bind)((_a = options === null || options === void 0 ? void 0 : options.scope) !== null && _a !== void 0 ? _a : 'singleton');

package/dist/server/entities/player.js

@@ -95,7 +95,7 @@ class Player {
      * @param vector - The target coordinates (x, y, z).
      */
     teleportClient(vector) {
-        this.emit('core:spawner:teleport', vector);
+        this.emit('opencore:spawner:teleport', vector);
     }
     /**
      * Disconnects the player from the server.

package/dist/server/error-handler.js

@@ -14,8 +14,8 @@ function normalizeError(error, origin) {
 }
 function handleCommandError(error, meta, playerId) {
     const appError = normalizeError(error, 'server');
-    logger_1.loggers.command.error(`Command execution failed: /${meta.name}`, {
-        command: meta.name,
+    logger_1.loggers.command.error(`Command execution failed: /${meta.command}`, {
+        command: meta.command,
         handler: meta.methodName,
         playerId,
         code: appError.code,

package/dist/server/helpers/resolve-method.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveMethod(instance: Record<string, any>, methodName: string, errorMessage: string): {
+    handler: Function;
+    handlerName: string;
+    proto: any;
+} | undefined;

package/dist/server/helpers/resolve-method.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveMethod = resolveMethod;
+const logger_1 = require("../../shared/logger");
+function resolveMethod(instance, methodName, errorMessage) {
+    const proto = Object.getPrototypeOf(instance);
+    const method = instance[methodName];
+    if (typeof method !== 'function') {
+        logger_1.loggers.scanner.error(errorMessage, {
+            className: instance.constructor.name,
+            methodName,
+        });
+        return;
+    }
+    const handler = method.bind(instance);
+    const handlerName = `${instance.constructor.name}.${methodName}`;
+    return { handler, handlerName, proto };
+}

package/dist/server/index.js

@@ -27,3 +27,5 @@ __exportStar(require("./setup"), exports);
 // Controllers
 require("./controllers/command.controller");
 require("./controllers/chat.controller");
+const container_1 = require("./container");
+globalThis.oc_container = container_1.di;

package/dist/server/loaders/playerSession.loader.js

@@ -11,9 +11,9 @@ const playerSessionLoader = () => {
     const persistenceService = tsyringe_1.container.resolve(persistence_service_1.PlayerPersistenceService);
     // Initialize persistence service (resolves provider if configured)
     persistenceService.initialize();
-    on('playerJoining', async (source) => {
+    on('playerJoining', async () => {
         var _a;
-        const clientId = Number(source);
+        const clientId = source;
         const license = (_a = GetPlayerIdentifier(clientId.toString(), 0)) !== null && _a !== void 0 ? _a : undefined;
         const player = playerManager.bind(clientId, { license });
         logger_1.loggers.session.info(`Player session created`, {
@@ -26,9 +26,18 @@ const playerSessionLoader = () => {
             clientId,
             license,
         });
+        setImmediate(() => {
+            const currentPlayer = playerManager.getByClient(clientId);
+            if (!currentPlayer)
+                return;
+            (0, core_event_bus_1.emitCoreEvent)('core:playerFullyConnected', {
+                clientId,
+                license,
+            });
+        });
     });
-    on('playerDropped', async () => {
-        const clientId = Number(global.source);
+    on('playerDropped', async (source) => {
+        const clientId = Number(source);
         const player = playerManager.getByClient(clientId);
         // Save player data before destroying session
         if (player) {

package/dist/server/services/command.service.d.ts

@@ -8,7 +8,7 @@ export declare class CommandService {
     register(meta: CommandMetadata, handler: Function): void;
     execute(player: Server.Player, commandName: string, args: string[], raw: string): Promise<void>;
     getAllCommands(): {
-        name: string;
+        command: string;
         description: string;
         usage: string;
     }[];

package/dist/server/services/command.service.js

@@ -18,26 +18,29 @@ const utils_1 = require("../../utils");
 const zod_1 = __importDefault(require("zod"));
 const security_handler_contract_1 = require("../templates/security/security-handler.contract");
 const logger_1 = require("../../shared/logger");
+const schema_generator_1 = require("../system/schema-generator");
 let CommandService = class CommandService {
     constructor(securityHandler) {
         this.securityHandler = securityHandler;
         this.commands = new Map();
     }
     register(meta, handler) {
-        this.commands.set(meta.name.toLowerCase(), { meta, handler });
-        logger_1.loggers.command.debug(`Registered: /${meta.name}${meta.schema ? ' [Validated]' : ''}`);
+        this.commands.set(meta.command.toLowerCase(), { meta, handler });
+        logger_1.loggers.command.debug(`Registered: /${meta.command}${meta.schema ? ' [Validated]' : ''}`);
     }
     async execute(player, commandName, args, raw) {
+        var _a;
         const entry = this.commands.get(commandName.toLowerCase());
         if (!entry) {
             return;
         }
         const { meta, handler } = entry;
         let validatedArgs = args;
-        if (meta.schema) {
+        // Use explicit schema or auto-generate from paramTypes
+        const schema = (_a = meta.schema) !== null && _a !== void 0 ? _a : (0, schema_generator_1.generateSchemaFromTypes)(meta.paramTypes);
+        if (schema) {
             try {
-                const result = await meta.schema.parseAsync(args);
-                validatedArgs = Array.isArray(result) ? result : [result];
+                validatedArgs = await schema.parseAsync(args);
             }
             catch (error) {
                 if (error instanceof zod_1.default.ZodError) {
@@ -60,7 +63,7 @@ let CommandService = class CommandService {
         return Array.from(this.commands.values()).map((c) => {
             var _a, _b;
             return ({
-                name: c.meta.name,
+                command: c.meta.command,
                 description: (_a = c.meta.description) !== null && _a !== void 0 ? _a : '',
                 usage: (_b = c.meta.usage) !== null && _b !== void 0 ? _b : '',
             });

package/dist/server/system/metadata-server.keys.d.ts

@@ -4,6 +4,7 @@ export declare const METADATA_KEYS: {
     NET_EVENT: string;
     TICK: string;
     CORE_EVENT: string;
+    FIVEM_EVENT: string;
     EXPORT: string;
     PUBLIC: string;
 };

package/dist/server/system/metadata-server.keys.js

@@ -7,6 +7,7 @@ exports.METADATA_KEYS = {
     NET_EVENT: 'core:meta:net_event',
     TICK: 'core:meta:tick',
     CORE_EVENT: 'core:meta:core_event',
+    FIVEM_EVENT: 'core:meta:fivem_event',
     EXPORT: 'core:meta:export',
     PUBLIC: 'core:meta:public',
 };

package/dist/server/system/processors/command.processor.d.ts

@@ -1,9 +1,9 @@
 import { DecoratorProcessor } from '../../../system/decorator-processor';
 import { CommandService } from '../../services';
-import { CommandConfig } from '../../decorators';
+import { CommandMetadata } from '../../decorators/command';
 export declare class CommandProcessor implements DecoratorProcessor {
     private commandService;
     readonly metadataKey: string;
     constructor(commandService: CommandService);
-    process(target: any, methodName: string, metadata: CommandConfig): void;
+    process(target: any, methodName: string, metadata: CommandMetadata): void;
 }

package/dist/server/system/processors/command.processor.js

@@ -20,8 +20,7 @@ let CommandProcessor = class CommandProcessor {
     }
     process(target, methodName, metadata) {
         const handler = target[methodName].bind(target);
-        const fullMeta = Object.assign(Object.assign({}, metadata), { methodName, target: target.constructor });
-        this.commandService.register(fullMeta, handler);
+        this.commandService.register(metadata, handler);
     }
 };
 exports.CommandProcessor = CommandProcessor;

package/dist/server/system/processors/coreEvent.processor.d.ts

@@ -1,7 +1,7 @@
 import { DecoratorProcessor } from '../../../system/decorator-processor';
 export declare class CoreEventProcessor implements DecoratorProcessor {
     readonly metadataKey: string;
-    process(target: any, methodName: string, metadata: {
+    process(instance: any, methodName: string, metadata: {
         event: string;
     }): void;
 }

package/dist/server/system/processors/coreEvent.processor.js

@@ -11,13 +11,16 @@ const tsyringe_1 = require("tsyringe");
 const core_event_bus_1 = require("../../bus/core-event-bus");
 const metadata_server_keys_1 = require("../metadata-server.keys");
 const logger_1 = require("../../../shared/logger");
+const resolve_method_1 = require("../../helpers/resolve-method");
 let CoreEventProcessor = class CoreEventProcessor {
     constructor() {
         this.metadataKey = metadata_server_keys_1.METADATA_KEYS.CORE_EVENT;
     }
-    process(target, methodName, metadata) {
-        const handler = target[methodName].bind(target);
-        const handlerName = `${target.constructor.name}.${methodName}`;
+    process(instance, methodName, metadata) {
+        const result = (0, resolve_method_1.resolveMethod)(instance, methodName, `[CoreEventProcessor] Method "${methodName}" not found`);
+        if (!result)
+            return;
+        const { handler, handlerName } = result;
         (0, core_event_bus_1.onCoreEvent)(metadata.event, (payload) => {
             try {
                 handler(payload);

package/dist/server/system/processors/export.processor.d.ts

@@ -1,7 +1,7 @@
 import { DecoratorProcessor } from '../../../system/decorator-processor';
 export declare class ExportProcessor implements DecoratorProcessor {
     readonly metadataKey: string;
-    process(target: any, methodName: string, metadata: {
+    process(instance: any, methodName: string, metadata: {
         exportName: string;
     }): void;
 }

package/dist/server/system/processors/export.processor.js

@@ -10,13 +10,17 @@ exports.ExportProcessor = void 0;
 const tsyringe_1 = require("tsyringe");
 const metadata_server_keys_1 = require("../metadata-server.keys");
 const logger_1 = require("../../../shared/logger");
+const resolve_method_1 = require("../../helpers/resolve-method");
 let ExportProcessor = class ExportProcessor {
     constructor() {
         this.metadataKey = metadata_server_keys_1.METADATA_KEYS.EXPORT;
     }
-    process(target, methodName, metadata) {
-        const handler = target[methodName].bind(target);
-        exports(metadata.exportName, handler);
+    process(instance, methodName, metadata) {
+        const result = (0, resolve_method_1.resolveMethod)(instance, methodName, `[ExportEventProcessor] Method "${methodName}" not found`);
+        if (!result)
+            return;
+        const { handler } = result;
+        globalThis.exports(metadata.exportName, handler);
         logger_1.loggers.exports.debug(`Registered: ${metadata.exportName}`);
     }
 };

package/dist/server/system/processors/fivemEvent.processor.d.ts

@@ -0,0 +1,7 @@
+import { DecoratorProcessor } from '../../../system/decorator-processor';
+export declare class FiveMEventProcessor implements DecoratorProcessor {
+    readonly metadataKey: string;
+    process(instance: any, methodName: string, metadata: {
+        event: string;
+    }): void;
+}

package/dist/server/system/processors/fivemEvent.processor.js

@@ -0,0 +1,40 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FiveMEventProcessor = void 0;
+const tsyringe_1 = require("tsyringe");
+const metadata_server_keys_1 = require("../metadata-server.keys");
+const logger_1 = require("../../../shared/logger");
+const resolve_method_1 = require("../../helpers/resolve-method");
+let FiveMEventProcessor = class FiveMEventProcessor {
+    constructor() {
+        this.metadataKey = metadata_server_keys_1.METADATA_KEYS.FIVEM_EVENT;
+    }
+    process(instance, methodName, metadata) {
+        const result = (0, resolve_method_1.resolveMethod)(instance, methodName, `[FiveMEventProcessor] Method "${methodName}" not found`);
+        if (!result)
+            return;
+        const { handler, handlerName } = result;
+        on(metadata.event, (...args) => {
+            try {
+                handler(...args);
+            }
+            catch (error) {
+                logger_1.loggers.eventBus.error(`Handler error in FiveMEvent`, {
+                    event: metadata.event,
+                    handler: handlerName,
+                }, error);
+            }
+        });
+        logger_1.loggers.eventBus.debug(`Registered FiveM event: ${metadata.event} -> ${handlerName}`);
+    }
+};
+exports.FiveMEventProcessor = FiveMEventProcessor;
+exports.FiveMEventProcessor = FiveMEventProcessor = __decorate([
+    (0, tsyringe_1.injectable)()
+], FiveMEventProcessor);

package/dist/server/system/processors/netEvent.processor.d.ts

@@ -7,5 +7,5 @@ export declare class NetEventProcessor implements DecoratorProcessor {
     private securityHandler;
     readonly metadataKey: string;
     constructor(playerService: PlayerService, securityHandler: SecurityHandlerContract);
-    process(target: any, methodName: string, metadata: NetEventOptions): void;
+    process(instance: any, methodName: string, metadata: NetEventOptions): void;
 }

package/dist/server/system/processors/netEvent.processor.js

@@ -20,19 +20,22 @@ const security_handler_contract_1 = require("../../templates/security/security-h
 const utils_1 = require("../../../utils");
 const logger_1 = require("../../../shared/logger");
 const zod_1 = __importDefault(require("zod"));
+const schema_generator_1 = require("../schema-generator");
+const resolve_method_1 = require("../../helpers/resolve-method");
 let NetEventProcessor = class NetEventProcessor {
     constructor(playerService, securityHandler) {
         this.playerService = playerService;
         this.securityHandler = securityHandler;
         this.metadataKey = metadata_server_keys_1.METADATA_KEYS.NET_EVENT;
     }
-    process(target, methodName, metadata) {
-        const handler = target[methodName].bind(target);
-        const handlerName = `${target.constructor.name}.${methodName}`;
-        const proto = Object.getPrototypeOf(target);
+    process(instance, methodName, metadata) {
+        const result = (0, resolve_method_1.resolveMethod)(instance, methodName, `[NetEventProcessor] Method "${methodName}" not found`);
+        if (!result)
+            return;
+        const { handler, handlerName, proto } = result;
         const isPublic = Reflect.getMetadata(metadata_server_keys_1.METADATA_KEYS.PUBLIC, proto, methodName) === true;
         onNet(metadata.eventName, async (...args) => {
-            const sourceId = Number(global.source);
+            const sourceId = Number(source);
             const player = this.playerService.getByClient(sourceId);
             if (!player) {
                 logger_1.loggers.netEvent.warn(`Event ignored: Player session not found`, {
@@ -53,11 +56,11 @@ let NetEventProcessor = class NetEventProcessor {
                 return;
             }
             let validatedArgs = args;
-            if (metadata.schema) {
+            const schema = (0, schema_generator_1.generateSchemaFromTypes)(metadata.paramTypes);
+            if (schema) {
                 try {
-                    const payload = args[0];
-                    const parsed = metadata.schema.parse(payload);
-                    validatedArgs = [parsed];
+                    const parsed = schema.parse(args);
+                    validatedArgs = Array.isArray(parsed) ? parsed : [parsed];
                 }
                 catch (error) {
                     if (error instanceof zod_1.default.ZodError) {

package/dist/server/system/processors.register.js

@@ -7,6 +7,7 @@ const security_handler_contract_1 = require("../templates/security/security-hand
 const command_processor_1 = require("./processors/command.processor");
 const coreEvent_processor_1 = require("./processors/coreEvent.processor");
 const export_processor_1 = require("./processors/export.processor");
+const fivemEvent_processor_1 = require("./processors/fivemEvent.processor");
 const netEvent_processor_1 = require("./processors/netEvent.processor");
 const tick_processor_1 = require("./processors/tick.processor");
 function registerSystemServer() {
@@ -15,6 +16,7 @@ function registerSystemServer() {
     container_1.di.register('DecoratorProcessor', { useClass: export_processor_1.ExportProcessor });
     container_1.di.register('DecoratorProcessor', { useClass: coreEvent_processor_1.CoreEventProcessor });
     container_1.di.register('DecoratorProcessor', { useClass: command_processor_1.CommandProcessor });
+    container_1.di.register('DecoratorProcessor', { useClass: fivemEvent_processor_1.FiveMEventProcessor });
     if (!container_1.di.isRegistered(security_handler_contract_1.SecurityHandlerContract)) {
         container_1.di.registerSingleton(security_handler_contract_1.SecurityHandlerContract, default_security_handler_1.DefaultSecurityHandler);
     }

package/dist/server/system/schema-generator.d.ts

@@ -0,0 +1,2 @@
+import z from 'zod';
+export declare function generateSchemaFromTypes(paramTypes: any[]): z.ZodTuple | null;

package/dist/server/system/schema-generator.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemaFromTypes = generateSchemaFromTypes;
+const zod_1 = __importDefault(require("zod"));
+const player_1 = require("../entities/player");
+function typeToZodSchema(type) {
+    switch (type) {
+        case String:
+            return zod_1.default.coerce.string();
+        case Number:
+            return zod_1.default.coerce.number();
+        case Boolean:
+            return zod_1.default.coerce.boolean();
+        case Array:
+            return zod_1.default.array(zod_1.default.any());
+        case Object:
+            return zod_1.default.any();
+        default:
+            return zod_1.default.any();
+    }
+}
+function generateSchemaFromTypes(paramTypes) {
+    var _a;
+    if (!paramTypes || paramTypes.length <= 1)
+        return null;
+    if (paramTypes[0] !== player_1.Player) {
+        throw new Error(`@OnNet: First parameter must be Player, got ${(_a = paramTypes[0]) === null || _a === void 0 ? void 0 : _a.name}`);
+    }
+    const argSchemas = paramTypes.slice(1).map(typeToZodSchema);
+    return zod_1.default.tuple(argSchemas);
+}

package/dist/server/templates/admin/admin.controller-template.d.ts

@@ -1,10 +1,12 @@
-import type { Server } from '../../..';
+import type { Player } from '../../entities';
+type CommandArgs = string[] | any;
 /**
  * Template for admin controller implementations.
  */
 export interface AdminControllerTemplate {
-    handleBanCommand(player: Server.Player, args: string[], raw?: string): Promise<void>;
-    handleKickCommand(player: Server.Player, args: string[], raw?: string): Promise<void>;
-    handleMuteCommand(player: Server.Player, args: string[], raw?: string): Promise<void>;
-    handleUnmuteCommand(player: Server.Player, args: string[], raw?: string): Promise<void>;
+    handleBanCommand(player: Player, args: CommandArgs, raw?: string): Promise<void>;
+    handleKickCommand(player: Player, args: CommandArgs, raw?: string): Promise<void>;
+    handleMuteCommand(player: Player, args: CommandArgs, raw?: string): Promise<void>;
+    handleUnmuteCommand(player: Player, args: CommandArgs, raw?: string): Promise<void>;
 }
+export {};

package/dist/server/templates/auth/auth-provider.contract.d.ts

@@ -1,5 +1,5 @@
-import { LinkedID } from '../../services';
-import { Server } from '../../..';
+import type { LinkedID } from '../../services';
+import type { Server } from '../../..';
 export interface AuthCredentials {
     /** Standard username/password auth */
     username?: string;