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

package/README.md

@@ -325,6 +325,16 @@ opencore/
 
 ---
 
+## Available Modules
+
+A module is a library belonging to the OpenCore family, where you can take advantage of its functionality if you wish, and where we provide the foundation for building a specific system.
+
+- [Open-core Identity](https://github.com/newcore-network/opencore-identity): Flexible identity and permission system for OpenCore. Provides multiple authentication strategies, role management, and permission-based authorization through the framework's Principal system. [NPM](https://www.npmjs.com/package/@open-core/identity).
+
+```bash
+pnpm add @open-core/identity
+```
+
 ## 🤝 Contributing
 
 Contributions are welcome! Please ensure:

package/dist/server/bootstrap.js

@@ -7,9 +7,9 @@ const templates_1 = require("./templates");
 const metadata_scanner_1 = require("../system/metadata.scanner");
 const processors_register_1 = require("./system/processors.register");
 const registers_1 = require("./services/registers");
-const decorators_1 = require("./decorators");
 const logger_1 = require("../shared/logger");
 const auth_provider_contract_1 = require("./templates/auth/auth-provider.contract");
+const controller_1 = require("./decorators/controller");
 const check = () => {
     if (!container_1.di.isRegistered(templates_1.PrincipalProviderContract)) {
         const errorMsg = 'No Principal Provider configured. ' +
@@ -52,6 +52,6 @@ async function initServer() {
     (0, playerSession_loader_1.playerSessionLoader)();
     logger_1.loggers.bootstrap.debug('Player session loader active');
     const scanner = container_1.di.resolve(metadata_scanner_1.MetadataScanner);
-    scanner.scan(decorators_1.serverControllerRegistry);
+    scanner.scan(controller_1.serverControllerRegistry);
     logger_1.loggers.bootstrap.info('OpenCore Server initialized successfully');
 }

package/dist/server/controllers/command.controller.d.ts

@@ -3,5 +3,5 @@ import { Player } from '../entities';
 export declare class CommandNetworkController {
     private readonly commandService;
     constructor(commandService: CommandService);
-    onCommandReceived(player: Player, commandName: string, args: string[], raw: string): Promise<void>;
+    onCommandReceived(player: Player, command: string, args: string[], raw: string): Promise<void>;
 }

package/dist/server/controllers/command.controller.js

@@ -10,7 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandNetworkController = void 0;
-const netEvent_1 = require("../decorators/netEvent");
+const onNet_1 = require("../decorators/onNet");
 const command_service_1 = require("../services/command.service");
 const entities_1 = require("../entities");
 const decorators_1 = require("../decorators");
@@ -19,16 +19,16 @@ let CommandNetworkController = class CommandNetworkController {
     constructor(commandService) {
         this.commandService = commandService;
     }
-    async onCommandReceived(player, commandName, args, raw) {
+    async onCommandReceived(player, command, args, raw) {
         try {
-            logger_1.loggers.command.trace(`Received: /${commandName}`, {
+            logger_1.loggers.command.trace(`Received: /${command}`, {
                 playerId: player.clientID,
                 playerName: player.name,
             });
-            await this.commandService.execute(player, commandName, args, raw);
+            await this.commandService.execute(player, command, args, raw);
         }
         catch (error) {
-            logger_1.loggers.command.error(`Execution failed: /${commandName}`, {
+            logger_1.loggers.command.error(`Execution failed: /${command}`, {
                 playerId: player.clientID,
             }, error);
         }
@@ -36,7 +36,7 @@ let CommandNetworkController = class CommandNetworkController {
 };
 exports.CommandNetworkController = CommandNetworkController;
 __decorate([
-    (0, netEvent_1.OnNet)('core:internal:executeCommand'),
+    (0, onNet_1.OnNet)('core:internal:executeCommand'),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [entities_1.Player, String, Array, String]),
     __metadata("design:returntype", Promise)

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

@@ -1,19 +1,49 @@
 import type { ClassConstructor } from '../../system/class-constructor';
 import type z from 'zod';
+import type { Player } from '../entities/player';
 export interface CommandConfig {
-    name: string;
+    /**
+     * The command name (e.g. "revive", "deposit"), used in chat "/revive"
+     */
+    command: string;
+    /**
+     * The command description, maybe "/help revive"
+     */
     description?: string;
+    /**
+     * The command usage, maybe "/revive <player>"
+     */
     usage?: string;
+    /**
+     * The command schema, used to validate the arguments, validated with zod
+     * @example
+     * ```ts
+     * Server.Command({
+     *   command: 'revive',
+     *   schema: z.object({
+     *     player: z.string(),
+     *   }),
+     * })
+     * ```
+     */
     schema?: z.ZodType;
 }
 export interface CommandMetadata extends CommandConfig {
     methodName: string;
     target: ClassConstructor;
+    paramTypes?: any;
 }
+type ServerCommandHandler = (player: Player, ...args: any[]) => any;
 /**
  * Decorator used to mark a controller method as a command.
- * The metadata is collected and later bound to FiveM via RegisterCommand().
+ * This method will be registered and then executed by the command service.
+ * It will depend on the chat you have implemented following the dependency conventions.
  *
- * @param name - The command name (e.g. "revive", "deposit")
+ * @param configOrName - The command name (e.g. "revive", "deposit")
+ * @validation zod schema
+ * @handlerSignature ```ts
+ *  (player: Server.Player, args: any[]) => any
+ * ```
  */
-export declare function Command(configOrName: string | CommandConfig): (target: any, propertyKey: string) => void;
+export declare function Command(configOrName: string | CommandConfig): <T extends ServerCommandHandler>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => void;
+export {};

package/dist/server/decorators/command.js

@@ -4,15 +4,20 @@ exports.Command = Command;
 const metadata_server_keys_1 = require("../system/metadata-server.keys");
 /**
  * Decorator used to mark a controller method as a command.
- * The metadata is collected and later bound to FiveM via RegisterCommand().
+ * This method will be registered and then executed by the command service.
+ * It will depend on the chat you have implemented following the dependency conventions.
  *
- * @param name - The command name (e.g. "revive", "deposit")
+ * @param configOrName - The command name (e.g. "revive", "deposit")
+ * @validation zod schema
+ * @handlerSignature ```ts
+ *  (player: Server.Player, args: any[]) => any
+ * ```
  */
 function Command(configOrName) {
-    return (target, propertyKey) => {
-        // Normalizamos: si pasa solo un string, creamos el objeto config
-        const config = typeof configOrName === 'string' ? { name: configOrName } : configOrName;
-        const metadata = Object.assign(Object.assign({}, config), { methodName: propertyKey, target: target.constructor });
+    return (target, propertyKey, descriptor) => {
+        const config = typeof configOrName === 'string' ? { command: configOrName } : configOrName;
+        const paramTypes = Reflect.getMetadata('design:paramtypes', target, propertyKey);
+        const metadata = Object.assign(Object.assign({}, config), { methodName: propertyKey, target: target.constructor, paramTypes });
         Reflect.defineMetadata(metadata_server_keys_1.METADATA_KEYS.COMMAND, metadata, target, propertyKey);
     };
 }

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

@@ -1,3 +1,25 @@
 import type { ClassConstructor } from '../../system/class-constructor';
 export declare const serverControllerRegistry: ClassConstructor[];
+/**
+ * Class decorator used to mark a class as a Server Controller.
+ *
+ * This decorator performs the following actions:
+ * 1. Marks the class as `@injectable` (via tsyringe) for dependency injection.
+ * 2. Defines metadata identifying the class as a 'server' type controller.
+ * 3. Automatically adds the class constructor to the `serverControllerRegistry`.
+ *
+ * @returns The decorator function to apply to the class.
+ *
+ * @example
+ * ```ts
+ * import { Controller } from '@core/server/decorators'
+ *
+ * @Server.Controller()
+ * export class PlayerController {
+ *   constructor(private playerService: PlayerService) {
+ *     // Dependency injection works automatically here
+ *   }
+ * }
+ * ```
+ */
 export declare function Controller(): (target: ClassConstructor) => void;

package/dist/server/decorators/controller.js

@@ -5,6 +5,28 @@ exports.Controller = Controller;
 const tsyringe_1 = require("tsyringe");
 const metadata_server_keys_1 = require("../system/metadata-server.keys");
 exports.serverControllerRegistry = [];
+/**
+ * Class decorator used to mark a class as a Server Controller.
+ *
+ * This decorator performs the following actions:
+ * 1. Marks the class as `@injectable` (via tsyringe) for dependency injection.
+ * 2. Defines metadata identifying the class as a 'server' type controller.
+ * 3. Automatically adds the class constructor to the `serverControllerRegistry`.
+ *
+ * @returns The decorator function to apply to the class.
+ *
+ * @example
+ * ```ts
+ * import { Controller } from '@core/server/decorators'
+ *
+ * @Server.Controller()
+ * export class PlayerController {
+ *   constructor(private playerService: PlayerService) {
+ *     // Dependency injection works automatically here
+ *   }
+ * }
+ * ```
+ */
 function Controller() {
     return function (target) {
         (0, tsyringe_1.injectable)()(target);

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

@@ -1,2 +1,22 @@
 import type { CoreEventMap } from '../types/core-events';
+/**
+ * Method decorator used to register a method as a listener for an internal OpenCore framework event.
+ *
+ * When the specified framework event is emitted, this method will be automatically triggered
+ * with the arguments provided by the event payload.
+ *
+ * @param event - The name of the core event to listen for (typed strictly to `CoreEventMap`).
+ *
+ *
+ * ```ts
+ * @Server.Controller()
+ * export class SystemController {
+ *
+ *   @OnCoreEvent('server:ready')
+ *   public onServerStart() {
+ *     console.log('OpenCore Framework is ready!')
+ *   }
+ * }
+ * ```
+ */
 export declare function OnCoreEvent<K extends keyof CoreEventMap>(event: K): (target: any, propertyKey: string) => void;

package/dist/server/decorators/coreEvent.js

@@ -2,6 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnCoreEvent = OnCoreEvent;
 const metadata_server_keys_1 = require("../system/metadata-server.keys");
+/**
+ * Method decorator used to register a method as a listener for an internal OpenCore framework event.
+ *
+ * When the specified framework event is emitted, this method will be automatically triggered
+ * with the arguments provided by the event payload.
+ *
+ * @param event - The name of the core event to listen for (typed strictly to `CoreEventMap`).
+ *
+ *
+ * ```ts
+ * @Server.Controller()
+ * export class SystemController {
+ *
+ *   @OnCoreEvent('server:ready')
+ *   public onServerStart() {
+ *     console.log('OpenCore Framework is ready!')
+ *   }
+ * }
+ * ```
+ */
 function OnCoreEvent(event) {
     return (target, propertyKey) => {
         Reflect.defineMetadata(metadata_server_keys_1.METADATA_KEYS.CORE_EVENT, { event }, target, propertyKey);

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

@@ -1 +1,39 @@
+/**
+ * Export
+ * -----------------------------------------
+ * Declares a method as an externally accessible export
+ * within the FiveM environment.
+ *
+ * Methods decorated with `@Export()` are automatically
+ * registered by the framework and exposed as native
+ * FXServer exports, allowing other resources to call them
+ * using:
+ *
+ *   exports.resourceName.exportName(...)
+ *
+ * This decorator is typically used inside controller
+ * classes, where the framework’s module loader inspects
+ * metadata to register commands, events and exports
+ * consistently.
+ *
+ * @param name Optional name to expose. If omitted,
+ *             the method name is used.
+ *
+ * ```ts
+ * @Server.Controller()
+ * export class AccountController {
+ *   @Server.Export('getAccountById')
+ *   getAccount(id: string) {
+ *     return this.accountService.find(id)
+ *   }
+ * }
+ *
+ * // From another resource:
+ * // const result = exports['core-resource'].getAccountById('1234')
+ *```
+ * Internally, this decorator stores metadata used by
+ * the server bootstrap to automatically register the
+ * export through FXServer's `global.exports` API.
+ *
+ */
 export declare function Export(name?: string): (target: any, propertyKey: string) => void;

package/dist/server/decorators/export.js

@@ -2,6 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Export = Export;
 const metadata_server_keys_1 = require("../system/metadata-server.keys");
+/**
+ * Export
+ * -----------------------------------------
+ * Declares a method as an externally accessible export
+ * within the FiveM environment.
+ *
+ * Methods decorated with `@Export()` are automatically
+ * registered by the framework and exposed as native
+ * FXServer exports, allowing other resources to call them
+ * using:
+ *
+ *   exports.resourceName.exportName(...)
+ *
+ * This decorator is typically used inside controller
+ * classes, where the framework’s module loader inspects
+ * metadata to register commands, events and exports
+ * consistently.
+ *
+ * @param name Optional name to expose. If omitted,
+ *             the method name is used.
+ *
+ * ```ts
+ * @Server.Controller()
+ * export class AccountController {
+ *   @Server.Export('getAccountById')
+ *   getAccount(id: string) {
+ *     return this.accountService.find(id)
+ *   }
+ * }
+ *
+ * // From another resource:
+ * // const result = exports['core-resource'].getAccountById('1234')
+ *```
+ * Internally, this decorator stores metadata used by
+ * the server bootstrap to automatically register the
+ * export through FXServer's `global.exports` API.
+ *
+ */
 function Export(name) {
     return (target, propertyKey) => {
         Reflect.defineMetadata(metadata_server_keys_1.METADATA_KEYS.EXPORT, { exportName: name || propertyKey }, target, propertyKey);

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

@@ -1,5 +1,56 @@
 export interface GuardOptions {
+    /**
+     * Minimum rank required to execute the method.
+     * Permissions and Role/Ranks are defined by your Principal Controller
+     */
     rank?: number;
+    /**
+     * Permission required to execute the method.
+     * Permissions and Role/Ranks are defined by your Principal Controller
+     */
     permission?: string;
 }
+/**
+ * Guard
+ * ------------------------------------------------------------
+ * Declarative access-control decorator for controller methods.
+ *
+ * `@Guard()` protects a method by enforcing rank and/or
+ * permission requirements before executing it.
+ *
+ * Requirements are evaluated through the AccessControlService,
+ * which determines whether the player (first argument of the
+ * method) is authorized to perform the action.
+ *
+ * Usage of this decorator allows you to express authorization
+ * rules directly at the controller level, promoting a clean
+ * and explicit security model.
+ *
+ * @param options GuardOptions
+ *   - rank: minimum rank required to execute the method.
+ *   - permission: specific permission required.
+ *
+ * Notes:
+ * - The decorated method must receive a `Server.Player`
+ *   instance as its first argument.
+ * - When compiling improperly (e.g., benchmarks, stripped
+ *   decorators), the PropertyDescriptor may be missing.
+ *   In that case, only metadata is recorded and execution
+ *   fallback is disabled. This should *never* occur in a
+ *   production environment.
+ *
+ * ```ts
+ * export class FactionController {
+ *   @Server.Guard({ permission: 'factions.manage' })
+ *   async createFaction(player: Player, dto: CreateFactionDTO) {
+ *     return this.service.create(dto)
+ *   }
+ *
+ *   @Server.Guard({ rank: 3 })
+ *   async promoteMember(player: Player, memberID: string) {
+ *     return this.service.promote(player, memberID)
+ *   }
+ * }
+ * ```
+ */
 export declare function Guard(options: GuardOptions): (target: any, propertyKey: string, descriptor?: PropertyDescriptor) => PropertyDescriptor | undefined;

package/dist/server/decorators/guard.js

@@ -4,6 +4,49 @@ exports.Guard = Guard;
 const container_1 = require("../container");
 const services_1 = require("../services");
 const logger_1 = require("../../shared/logger");
+/**
+ * Guard
+ * ------------------------------------------------------------
+ * Declarative access-control decorator for controller methods.
+ *
+ * `@Guard()` protects a method by enforcing rank and/or
+ * permission requirements before executing it.
+ *
+ * Requirements are evaluated through the AccessControlService,
+ * which determines whether the player (first argument of the
+ * method) is authorized to perform the action.
+ *
+ * Usage of this decorator allows you to express authorization
+ * rules directly at the controller level, promoting a clean
+ * and explicit security model.
+ *
+ * @param options GuardOptions
+ *   - rank: minimum rank required to execute the method.
+ *   - permission: specific permission required.
+ *
+ * Notes:
+ * - The decorated method must receive a `Server.Player`
+ *   instance as its first argument.
+ * - When compiling improperly (e.g., benchmarks, stripped
+ *   decorators), the PropertyDescriptor may be missing.
+ *   In that case, only metadata is recorded and execution
+ *   fallback is disabled. This should *never* occur in a
+ *   production environment.
+ *
+ * ```ts
+ * export class FactionController {
+ *   @Server.Guard({ permission: 'factions.manage' })
+ *   async createFaction(player: Player, dto: CreateFactionDTO) {
+ *     return this.service.create(dto)
+ *   }
+ *
+ *   @Server.Guard({ rank: 3 })
+ *   async promoteMember(player: Player, memberID: string) {
+ *     return this.service.promote(player, memberID)
+ *   }
+ * }
+ * ```
+ */
 function Guard(options) {
     return function (target, propertyKey, descriptor) {
         var _a;

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

@@ -1,10 +1,10 @@
 export * from './bind';
 export * from './utils';
-export * from './command';
+export { Command, CommandConfig } from './command';
 export * from './coreEvent';
-export * from './netEvent';
+export * from './onNet';
 export * from './onTick';
-export * from './controller';
+export { Controller } from './controller';
 export * from './throttle';
 export * from './guard';
 export * from './requiresState';

package/dist/server/decorators/index.js

@@ -14,13 +14,16 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = exports.Command = void 0;
 __exportStar(require("./bind"), exports);
 __exportStar(require("./utils"), exports);
-__exportStar(require("./command"), exports);
+var command_1 = require("./command");
+Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });
 __exportStar(require("./coreEvent"), exports);
-__exportStar(require("./netEvent"), exports);
+__exportStar(require("./onNet"), exports);
 __exportStar(require("./onTick"), exports);
-__exportStar(require("./controller"), exports);
+var controller_1 = require("./controller");
+Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return controller_1.Controller; } });
 __exportStar(require("./throttle"), exports);
 __exportStar(require("./guard"), exports);
 __exportStar(require("./requiresState"), exports);

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

@@ -0,0 +1,58 @@
+import type { z } from 'zod';
+import type { Player } from '../entities/player';
+export interface NetEventOptions {
+    eventName: string;
+    schema?: z.ZodType;
+    paramTypes?: any;
+}
+type ServerNetHandler<TArgs extends any[] = any[]> = (player: Player, ...args: TArgs) => any;
+/**
+ * Registers a server-side network event handler.
+ *
+ * The decorated method is invoked when the client triggers
+ * `emitNet(eventName, ...)`.
+ *
+ * ## Player Injection
+ * The first argument of the handler **must be `Player`** and is automatically
+ * replaced with a `Server.Player` instance representing the client that
+ * fired the event. You do NOT need to read `source` manually.
+ *
+ * ## Auto-Validation
+ * Arguments after `Player` are automatically validated based on their TypeScript types:
+ * - `string` → `z.string()`
+ * - `number` → `z.number()`
+ * - `boolean` → `z.boolean()`
+ * - `any[]` → `z.array(z.any())` (array content not validated)
+ *
+ * ## Explicit Schema (Advanced)
+ * For stricter validation (ranges, formats, nested objects), provide a Zod schema:
+ *
+ * @example Auto-validation (simple)
+ * ```ts
+ * @OnNet("auth:login")
+ * handleLogin(player: Player, username: string, password: string) {
+ *   // username and password are validated as strings automatically
+ * }
+ * ```
+ *
+ * @example Explicit schema (strict validation)
+ * ```ts
+ * const transferSchema = z.object({
+ *   targetId: z.number().positive(),
+ *   amount: z.number().min(1).max(1000000),
+ * })
+ *
+ * @OnNet("bank:transfer", { schema: transferSchema })
+ * handleTransfer(player: Player, data: z.infer<typeof transferSchema>) {
+ *   // data.amount is guaranteed to be between 1 and 1,000,000
+ * }
+ * ```
+ *
+ * @param eventName - The network event name to listen for.
+ * @param options - Optional configuration object.
+ * @param options.schema - Zod schema for strict payload validation.
+ */
+export declare function OnNet<TArgs extends any[]>(eventName: string, options?: {
+    schema?: z.ZodType;
+}): <H extends ServerNetHandler<TArgs>>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<H>) => void;
+export {};

package/dist/server/decorators/onNet.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnNet = OnNet;
+const metadata_server_keys_1 = require("../system/metadata-server.keys");
+/**
+ * Registers a server-side network event handler.
+ *
+ * The decorated method is invoked when the client triggers
+ * `emitNet(eventName, ...)`.
+ *
+ * ## Player Injection
+ * The first argument of the handler **must be `Player`** and is automatically
+ * replaced with a `Server.Player` instance representing the client that
+ * fired the event. You do NOT need to read `source` manually.
+ *
+ * ## Auto-Validation
+ * Arguments after `Player` are automatically validated based on their TypeScript types:
+ * - `string` → `z.string()`
+ * - `number` → `z.number()`
+ * - `boolean` → `z.boolean()`
+ * - `any[]` → `z.array(z.any())` (array content not validated)
+ *
+ * ## Explicit Schema (Advanced)
+ * For stricter validation (ranges, formats, nested objects), provide a Zod schema:
+ *
+ * @example Auto-validation (simple)
+ * ```ts
+ * @OnNet("auth:login")
+ * handleLogin(player: Player, username: string, password: string) {
+ *   // username and password are validated as strings automatically
+ * }
+ * ```
+ *
+ * @example Explicit schema (strict validation)
+ * ```ts
+ * const transferSchema = z.object({
+ *   targetId: z.number().positive(),
+ *   amount: z.number().min(1).max(1000000),
+ * })
+ *
+ * @OnNet("bank:transfer", { schema: transferSchema })
+ * handleTransfer(player: Player, data: z.infer<typeof transferSchema>) {
+ *   // data.amount is guaranteed to be between 1 and 1,000,000
+ * }
+ * ```
+ *
+ * @param eventName - The network event name to listen for.
+ * @param options - Optional configuration object.
+ * @param options.schema - Zod schema for strict payload validation.
+ */
+function OnNet(eventName, options) {
+    return (target, propertyKey, descriptor) => {
+        const paramTypes = Reflect.getMetadata('design:paramtypes', target, propertyKey);
+        const metadata = { eventName, schema: options === null || options === void 0 ? void 0 : options.schema, paramTypes };
+        Reflect.defineMetadata(metadata_server_keys_1.METADATA_KEYS.NET_EVENT, metadata, target, propertyKey);
+    };
+}

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

@@ -1 +1,32 @@
+/**
+ * OnTick
+ * ------------------------------------------------------------
+ * Marks a method to be executed on every server tick.
+ *
+ * Methods decorated with `@OnTick()` are automatically
+ * registered by the framework's scheduler and invoked on each
+ * FXServer tick (~ every 0–10 ms depending on workload).
+ *
+ * This decorator should be used for lightweight recurring
+ * logic: status updates, background checks, cleanup tasks,
+ * or time-based processes relevant to gameplay.
+ *
+ * Heavy or blocking operations should be avoided inside tick
+ * handlers, as they directly impact global server performance.
+ *
+ * ```ts
+ * export class SyncController {
+ *   @OnTick()
+ *   updatePlayers() {
+ *     // Runs every tick
+ *     this.service.syncPositions()
+ *   }
+ * }
+ *
+ * ```
+ *
+ * Internally, the decorator only stores metadata. The
+ * server bootstrap scans for this metadata and binds the
+ * method to FiveM's tick cycle.
+ */
 export declare function OnTick(): (target: any, propertyKey: string) => void;